Completed
Push — feature/react_tristan ( 07e079 )
by Tristan
08:58
created

public/js/modernizr.js   B

Complexity

Conditions 1
Paths 480

Size

Total Lines 85
Code Lines 39

Duplication

Lines 85
Ratio 100 %

Importance

Changes 0
Metric Value
cc 1
eloc 39
nc 480
nop 1
dl 85
loc 85
rs 8.9439
c 0
b 0
f 0

6 Functions

Rating   Name   Duplication   Size   Complexity  
A modernizr.js ➔ __webpack_require__ 22 22 2
A __webpack_require__.o 1 1 1
A __webpack_require__.n 7 7 3
A __webpack_require__.r 6 6 3
A __webpack_require__.d 5 5 2
C __webpack_require__.t 10 10 10

How to fix   Long Method   

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

1 View Code Duplication
/******/ (function(modules) { // webpackBootstrap
0 ignored issues
show
Duplication introduced by
This code seems to be duplicated in your project.
Loading history...
2
/******/ 	// The module cache
3
/******/ 	var installedModules = {};
4
/******/
5
/******/ 	// The require function
6
/******/ 	function __webpack_require__(moduleId) {
7
/******/
8
/******/ 		// Check if module is in cache
9
/******/ 		if(installedModules[moduleId]) {
10
/******/ 			return installedModules[moduleId].exports;
11
/******/ 		}
12
/******/ 		// Create a new module (and put it into the cache)
13
/******/ 		var module = installedModules[moduleId] = {
14
/******/ 			i: moduleId,
15
/******/ 			l: false,
16
/******/ 			exports: {}
17
/******/ 		};
18
/******/
19
/******/ 		// Execute the module function
20
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
21
/******/
22
/******/ 		// Flag the module as loaded
23
/******/ 		module.l = true;
24
/******/
25
/******/ 		// Return the exports of the module
26
/******/ 		return module.exports;
27
/******/ 	}
28
/******/
29
/******/
30
/******/ 	// expose the modules object (__webpack_modules__)
31
/******/ 	__webpack_require__.m = modules;
32
/******/
33
/******/ 	// expose the module cache
34
/******/ 	__webpack_require__.c = installedModules;
35
/******/
36
/******/ 	// define getter function for harmony exports
37
/******/ 	__webpack_require__.d = function(exports, name, getter) {
38
/******/ 		if(!__webpack_require__.o(exports, name)) {
39
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
40
/******/ 		}
41
/******/ 	};
42
/******/
43
/******/ 	// define __esModule on exports
44
/******/ 	__webpack_require__.r = function(exports) {
45
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
0 ignored issues
show
Bug introduced by
The variable Symbol seems to be never declared. If this is a global, consider adding a /** global: Symbol */ comment.

This checks looks for references to variables that have not been declared. This is most likey a typographical error or a variable has been renamed.

To learn more about declaring variables in Javascript, see the MDN.

Loading history...
46
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
47
/******/ 		}
48
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
49
/******/ 	};
50
/******/
51
/******/ 	// create a fake namespace object
52
/******/ 	// mode & 1: value is a module id, require it
53
/******/ 	// mode & 2: merge all properties of value into the ns
54
/******/ 	// mode & 4: return value when already ns object
55
/******/ 	// mode & 8|1: behave like require
56
/******/ 	__webpack_require__.t = function(value, mode) {
57
/******/ 		if(mode & 1) value = __webpack_require__(value);
0 ignored issues
show
Coding Style Best Practice introduced by
Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

Consider adding curly braces around all statements when they are executed conditionally. This is optional if there is only one statement, but leaving them out can lead to unexpected behaviour if another statement is added later.

Consider:

if (a > 0)
    b = 42;

If you or someone else later decides to put another statement in, only the first statement will be executed.

if (a > 0)
    console.log("a > 0");
    b = 42;

In this case the statement b = 42 will always be executed, while the logging statement will be executed conditionally.

if (a > 0) {
    console.log("a > 0");
    b = 42;
}

ensures that the proper code will be executed conditionally no matter how many statements are added or removed.

Loading history...
introduced by
You have used a bitwise operator & in a condition. Did you maybe want to use the logical operator &&
Loading history...
58
/******/ 		if(mode & 8) return value;
0 ignored issues
show
introduced by
You have used a bitwise operator & in a condition. Did you maybe want to use the logical operator &&
Loading history...
Coding Style Best Practice introduced by
Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

Consider adding curly braces around all statements when they are executed conditionally. This is optional if there is only one statement, but leaving them out can lead to unexpected behaviour if another statement is added later.

Consider:

if (a > 0)
    b = 42;

If you or someone else later decides to put another statement in, only the first statement will be executed.

if (a > 0)
    console.log("a > 0");
    b = 42;

In this case the statement b = 42 will always be executed, while the logging statement will be executed conditionally.

if (a > 0) {
    console.log("a > 0");
    b = 42;
}

ensures that the proper code will be executed conditionally no matter how many statements are added or removed.

Loading history...
59
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
0 ignored issues
show
Coding Style Best Practice introduced by
Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

Consider adding curly braces around all statements when they are executed conditionally. This is optional if there is only one statement, but leaving them out can lead to unexpected behaviour if another statement is added later.

Consider:

if (a > 0)
    b = 42;

If you or someone else later decides to put another statement in, only the first statement will be executed.

if (a > 0)
    console.log("a > 0");
    b = 42;

In this case the statement b = 42 will always be executed, while the logging statement will be executed conditionally.

if (a > 0) {
    console.log("a > 0");
    b = 42;
}

ensures that the proper code will be executed conditionally no matter how many statements are added or removed.

Loading history...
introduced by
You have used a bitwise operator & in a condition. Did you maybe want to use the logical operator &&
Loading history...
60
/******/ 		var ns = Object.create(null);
61
/******/ 		__webpack_require__.r(ns);
62
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
63
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
0 ignored issues
show
introduced by
You have used a bitwise operator & in a condition. Did you maybe want to use the logical operator &&
Loading history...
unused-code introduced by
The call to bind does not seem necessary since the function does not use this. Consider calling it directly.
Loading history...
Coding Style Best Practice introduced by
Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

Consider adding curly braces around all statements when they are executed conditionally. This is optional if there is only one statement, but leaving them out can lead to unexpected behaviour if another statement is added later.

Consider:

if (a > 0)
    b = 42;

If you or someone else later decides to put another statement in, only the first statement will be executed.

if (a > 0)
    console.log("a > 0");
    b = 42;

In this case the statement b = 42 will always be executed, while the logging statement will be executed conditionally.

if (a > 0) {
    console.log("a > 0");
    b = 42;
}

ensures that the proper code will be executed conditionally no matter how many statements are added or removed.

Loading history...
Complexity introduced by
A for in loop automatically includes the property of any prototype object, consider checking the key using hasOwnProperty.

When iterating over the keys of an object, this includes not only the keys of the object, but also keys contained in the prototype of that object. It is generally a best practice to check for these keys specifically:

var someObject;
for (var key in someObject) {
    if ( ! someObject.hasOwnProperty(key)) {
        continue; // Skip keys from the prototype.
    }

    doSomethingWith(key);
}
Loading history...
64
/******/ 		return ns;
65
/******/ 	};
66
/******/
67
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
68
/******/ 	__webpack_require__.n = function(module) {
69
/******/ 		var getter = module && module.__esModule ?
70
/******/ 			function getDefault() { return module['default']; } :
71
/******/ 			function getModuleExports() { return module; };
72
/******/ 		__webpack_require__.d(getter, 'a', getter);
73
/******/ 		return getter;
74
/******/ 	};
75
/******/
76
/******/ 	// Object.prototype.hasOwnProperty.call
77
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
78
/******/
79
/******/ 	// __webpack_public_path__
80
/******/ 	__webpack_require__.p = "/";
81
/******/
82
/******/
83
/******/ 	// Load entry module and return exports
84
/******/ 	return __webpack_require__(__webpack_require__.s = 3);
85
/******/ })
86
/************************************************************************/
87
/******/ ({
88
89
/***/ "./resources/assets/js/modernizr.js":
90
/*!******************************************!*\
91
  !*** ./resources/assets/js/modernizr.js ***!
92
  \******************************************/
93
/*! no static exports found */
94
/***/ (function(module, exports) {
0 ignored issues
show
Unused Code introduced by
The parameter exports is not used and could be removed.

This check looks for parameters in functions that are not used in the function body and are not followed by other parameters which are used inside the function.

Loading history...
Unused Code introduced by
The parameter module is not used and could be removed.

This check looks for parameters in functions that are not used in the function body and are not followed by other parameters which are used inside the function.

Loading history...
95
96
function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }
0 ignored issues
show
Bug introduced by
The variable Symbol seems to be never declared. If this is a global, consider adding a /** global: Symbol */ comment.

This checks looks for references to variables that have not been declared. This is most likey a typographical error or a variable has been renamed.

To learn more about declaring variables in Javascript, see the MDN.

Loading history...
97
98
function _typeof(obj) {
99
  if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") {
0 ignored issues
show
Bug introduced by
The variable Symbol seems to be never declared. If this is a global, consider adding a /** global: Symbol */ comment.

This checks looks for references to variables that have not been declared. This is most likey a typographical error or a variable has been renamed.

To learn more about declaring variables in Javascript, see the MDN.

Loading history...
100
    _typeof = function _typeof(obj) {
101
      return _typeof2(obj);
102
    };
103
  } else {
104
    _typeof = function _typeof(obj) {
105
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);
0 ignored issues
show
Bug introduced by
The variable Symbol seems to be never declared. If this is a global, consider adding a /** global: Symbol */ comment.

This checks looks for references to variables that have not been declared. This is most likey a typographical error or a variable has been renamed.

To learn more about declaring variables in Javascript, see the MDN.

Loading history...
106
    };
107
  }
108
109
  return _typeof(obj);
110
}
111
/*! modernizr 3.5.0 (Custom Build) | MIT *
112
 * https://modernizr.com/download/?-emoji-svg-touchevents-setclasses !*/
113
114
115 View Code Duplication
!function (e, t, n) {
0 ignored issues
show
Duplication introduced by
This code seems to be duplicated in your project.
Loading history...
116
  function o(e, t) {
117
    return _typeof(e) === t;
118
  }
119
120
  function a() {
121
    var e, t, n, a, s, i, r;
122
123
    for (var l in c) {
124
      if (c.hasOwnProperty(l)) {
125
        if (e = [], t = c[l], t.name && (e.push(t.name.toLowerCase()), t.options && t.options.aliases && t.options.aliases.length)) for (n = 0; n < t.options.aliases.length; n++) {
0 ignored issues
show
Comprehensibility introduced by
Usage of the sequence operator is discouraged, since it may lead to obfuscated code.

The sequence or comma operator allows the inclusion of multiple expressions where only is permitted. The result of the sequence is the value of the last expression.

This operator is most often used in for statements.

Used in another places it can make code hard to read, especially when people do not realize it even exists as a seperate operator.

This check looks for usage of the sequence operator in locations where it is not necessary and could be replaced by a series of expressions or statements.

var a,b,c;

a = 1, b = 1,  c= 3;

could just as well be written as:

var a,b,c;

a = 1;
b = 1;
c = 3;

To learn more about the sequence operator, please refer to the MDN.

Loading history...
Coding Style Best Practice introduced by
Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

Consider adding curly braces around all statements when they are executed conditionally. This is optional if there is only one statement, but leaving them out can lead to unexpected behaviour if another statement is added later.

Consider:

if (a > 0)
    b = 42;

If you or someone else later decides to put another statement in, only the first statement will be executed.

if (a > 0)
    console.log("a > 0");
    b = 42;

In this case the statement b = 42 will always be executed, while the logging statement will be executed conditionally.

if (a > 0) {
    console.log("a > 0");
    b = 42;
}

ensures that the proper code will be executed conditionally no matter how many statements are added or removed.

Loading history...
126
          e.push(t.options.aliases[n].toLowerCase());
127
        }
128
129
        for (a = o(t.fn, "function") ? t.fn() : t.fn, s = 0; s < e.length; s++) {
130
          i = e[s], r = i.split("."), 1 === r.length ? Modernizr[r[0]] = a : (!Modernizr[r[0]] || Modernizr[r[0]] instanceof Boolean || (Modernizr[r[0]] = new Boolean(Modernizr[r[0]])), Modernizr[r[0]][r[1]] = a), f.push((a ? "" : "no-") + r.join("-"));
0 ignored issues
show
Comprehensibility introduced by
Usage of the sequence operator is discouraged, since it may lead to obfuscated code.

The sequence or comma operator allows the inclusion of multiple expressions where only is permitted. The result of the sequence is the value of the last expression.

This operator is most often used in for statements.

Used in another places it can make code hard to read, especially when people do not realize it even exists as a seperate operator.

This check looks for usage of the sequence operator in locations where it is not necessary and could be replaced by a series of expressions or statements.

var a,b,c;

a = 1, b = 1,  c= 3;

could just as well be written as:

var a,b,c;

a = 1;
b = 1;
c = 3;

To learn more about the sequence operator, please refer to the MDN.

Loading history...
131
        }
132
      }
133
    }
134
  }
135
136
  function s(e) {
137
    var t = u.className,
138
        n = Modernizr._config.classPrefix || "";
139
140
    if (p && (t = t.baseVal), Modernizr._config.enableJSClass) {
0 ignored issues
show
Comprehensibility introduced by
Usage of the sequence operator is discouraged, since it may lead to obfuscated code.

The sequence or comma operator allows the inclusion of multiple expressions where only is permitted. The result of the sequence is the value of the last expression.

This operator is most often used in for statements.

Used in another places it can make code hard to read, especially when people do not realize it even exists as a seperate operator.

This check looks for usage of the sequence operator in locations where it is not necessary and could be replaced by a series of expressions or statements.

var a,b,c;

a = 1, b = 1,  c= 3;

could just as well be written as:

var a,b,c;

a = 1;
b = 1;
c = 3;

To learn more about the sequence operator, please refer to the MDN.

Loading history...
141
      var o = new RegExp("(^|\\s)" + n + "no-js(\\s|$)");
142
      t = t.replace(o, "$1" + n + "js$2");
143
    }
144
145
    Modernizr._config.enableClasses && (t += " " + n + e.join(" " + n), p ? u.className.baseVal = t : u.className = t);
0 ignored issues
show
Comprehensibility introduced by
Usage of the sequence operator is discouraged, since it may lead to obfuscated code.

The sequence or comma operator allows the inclusion of multiple expressions where only is permitted. The result of the sequence is the value of the last expression.

This operator is most often used in for statements.

Used in another places it can make code hard to read, especially when people do not realize it even exists as a seperate operator.

This check looks for usage of the sequence operator in locations where it is not necessary and could be replaced by a series of expressions or statements.

var a,b,c;

a = 1, b = 1,  c= 3;

could just as well be written as:

var a,b,c;

a = 1;
b = 1;
c = 3;

To learn more about the sequence operator, please refer to the MDN.

Loading history...
146
  }
147
148
  function i() {
149
    return "function" != typeof t.createElement ? t.createElement(arguments[0]) : p ? t.createElementNS.call(t, "http://www.w3.org/2000/svg", arguments[0]) : t.createElement.apply(t, arguments);
150
  }
151
152
  function r() {
153
    var e = t.body;
154
    return e || (e = i(p ? "svg" : "body"), e.fake = !0), e;
0 ignored issues
show
Comprehensibility introduced by
Usage of the sequence operator is discouraged, since it may lead to obfuscated code.

The sequence or comma operator allows the inclusion of multiple expressions where only is permitted. The result of the sequence is the value of the last expression.

This operator is most often used in for statements.

Used in another places it can make code hard to read, especially when people do not realize it even exists as a seperate operator.

This check looks for usage of the sequence operator in locations where it is not necessary and could be replaced by a series of expressions or statements.

var a,b,c;

a = 1, b = 1,  c= 3;

could just as well be written as:

var a,b,c;

a = 1;
b = 1;
c = 3;

To learn more about the sequence operator, please refer to the MDN.

Loading history...
155
  }
156
157
  function l(e, n, o, a) {
158
    var s,
159
        l,
160
        f,
161
        c,
162
        d = "modernizr",
163
        p = i("div"),
164
        v = r();
165
    if (parseInt(o, 10)) for (; o--;) {
0 ignored issues
show
Coding Style Best Practice introduced by
Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

Consider adding curly braces around all statements when they are executed conditionally. This is optional if there is only one statement, but leaving them out can lead to unexpected behaviour if another statement is added later.

Consider:

if (a > 0)
    b = 42;

If you or someone else later decides to put another statement in, only the first statement will be executed.

if (a > 0)
    console.log("a > 0");
    b = 42;

In this case the statement b = 42 will always be executed, while the logging statement will be executed conditionally.

if (a > 0) {
    console.log("a > 0");
    b = 42;
}

ensures that the proper code will be executed conditionally no matter how many statements are added or removed.

Loading history...
166
      f = i("div"), f.id = a ? a[o] : d + (o + 1), p.appendChild(f);
0 ignored issues
show
Comprehensibility introduced by
Usage of the sequence operator is discouraged, since it may lead to obfuscated code.

The sequence or comma operator allows the inclusion of multiple expressions where only is permitted. The result of the sequence is the value of the last expression.

This operator is most often used in for statements.

Used in another places it can make code hard to read, especially when people do not realize it even exists as a seperate operator.

This check looks for usage of the sequence operator in locations where it is not necessary and could be replaced by a series of expressions or statements.

var a,b,c;

a = 1, b = 1,  c= 3;

could just as well be written as:

var a,b,c;

a = 1;
b = 1;
c = 3;

To learn more about the sequence operator, please refer to the MDN.

Loading history...
167
    }
168
    return s = i("style"), s.type = "text/css", s.id = "s" + d, (v.fake ? v : p).appendChild(s), v.appendChild(p), s.styleSheet ? s.styleSheet.cssText = e : s.appendChild(t.createTextNode(e)), p.id = d, v.fake && (v.style.background = "", v.style.overflow = "hidden", c = u.style.overflow, u.style.overflow = "hidden", u.appendChild(v)), l = n(p, e), v.fake ? (v.parentNode.removeChild(v), u.style.overflow = c, u.offsetHeight) : p.parentNode.removeChild(p), !!l;
0 ignored issues
show
Bug introduced by
The variable c seems to not be initialized for all possible execution paths.
Loading history...
Comprehensibility introduced by
Usage of the sequence operator is discouraged, since it may lead to obfuscated code.

The sequence or comma operator allows the inclusion of multiple expressions where only is permitted. The result of the sequence is the value of the last expression.

This operator is most often used in for statements.

Used in another places it can make code hard to read, especially when people do not realize it even exists as a seperate operator.

This check looks for usage of the sequence operator in locations where it is not necessary and could be replaced by a series of expressions or statements.

var a,b,c;

a = 1, b = 1,  c= 3;

could just as well be written as:

var a,b,c;

a = 1;
b = 1;
c = 3;

To learn more about the sequence operator, please refer to the MDN.

Loading history...
169
  }
170
171
  var f = [],
172
      c = [],
173
      d = {
174
    _version: "3.5.0",
175
    _config: {
176
      classPrefix: "",
177
      enableClasses: !0,
178
      enableJSClass: !0,
179
      usePrefixes: !0
180
    },
181
    _q: [],
182
    on: function on(e, t) {
183
      var n = this;
184
      setTimeout(function () {
185
        t(n[e]);
186
      }, 0);
187
    },
188
    addTest: function addTest(e, t, n) {
189
      c.push({
190
        name: e,
191
        fn: t,
192
        options: n
193
      });
194
    },
195
    addAsyncTest: function addAsyncTest(e) {
196
      c.push({
197
        name: null,
198
        fn: e
199
      });
200
    }
201
  },
202
      Modernizr = function Modernizr() {};
203
204
  Modernizr.prototype = d, Modernizr = new Modernizr(), Modernizr.addTest("svg", !!t.createElementNS && !!t.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGRect);
0 ignored issues
show
Comprehensibility introduced by
Usage of the sequence operator is discouraged, since it may lead to obfuscated code.

The sequence or comma operator allows the inclusion of multiple expressions where only is permitted. The result of the sequence is the value of the last expression.

This operator is most often used in for statements.

Used in another places it can make code hard to read, especially when people do not realize it even exists as a seperate operator.

This check looks for usage of the sequence operator in locations where it is not necessary and could be replaced by a series of expressions or statements.

var a,b,c;

a = 1, b = 1,  c= 3;

could just as well be written as:

var a,b,c;

a = 1;
b = 1;
c = 3;

To learn more about the sequence operator, please refer to the MDN.

Loading history...
205
  var u = t.documentElement,
206
      p = "svg" === u.nodeName.toLowerCase();
207
  Modernizr.addTest("canvas", function () {
0 ignored issues
show
Comprehensibility introduced by
Usage of the sequence operator is discouraged, since it may lead to obfuscated code.

The sequence or comma operator allows the inclusion of multiple expressions where only is permitted. The result of the sequence is the value of the last expression.

This operator is most often used in for statements.

Used in another places it can make code hard to read, especially when people do not realize it even exists as a seperate operator.

This check looks for usage of the sequence operator in locations where it is not necessary and could be replaced by a series of expressions or statements.

var a,b,c;

a = 1, b = 1,  c= 3;

could just as well be written as:

var a,b,c;

a = 1;
b = 1;
c = 3;

To learn more about the sequence operator, please refer to the MDN.

Loading history...
208
    var e = i("canvas");
209
    return !(!e.getContext || !e.getContext("2d"));
210
  }), Modernizr.addTest("canvastext", function () {
211
    return Modernizr.canvas === !1 ? !1 : "function" == typeof i("canvas").getContext("2d").fillText;
212
  }), Modernizr.addTest("emoji", function () {
213
    if (!Modernizr.canvastext) return !1;
0 ignored issues
show
Coding Style Best Practice introduced by
Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

Consider adding curly braces around all statements when they are executed conditionally. This is optional if there is only one statement, but leaving them out can lead to unexpected behaviour if another statement is added later.

Consider:

if (a > 0)
    b = 42;

If you or someone else later decides to put another statement in, only the first statement will be executed.

if (a > 0)
    console.log("a > 0");
    b = 42;

In this case the statement b = 42 will always be executed, while the logging statement will be executed conditionally.

if (a > 0) {
    console.log("a > 0");
    b = 42;
}

ensures that the proper code will be executed conditionally no matter how many statements are added or removed.

Loading history...
214
    var t = e.devicePixelRatio || 1,
215
        n = 12 * t,
216
        o = i("canvas"),
217
        a = o.getContext("2d");
218
    return a.fillStyle = "#f00", a.textBaseline = "top", a.font = "32px Arial", a.fillText("🐨", 0, 0), 0 !== a.getImageData(n, n, 1, 1).data[0];
0 ignored issues
show
Comprehensibility introduced by
Usage of the sequence operator is discouraged, since it may lead to obfuscated code.

The sequence or comma operator allows the inclusion of multiple expressions where only is permitted. The result of the sequence is the value of the last expression.

This operator is most often used in for statements.

Used in another places it can make code hard to read, especially when people do not realize it even exists as a seperate operator.

This check looks for usage of the sequence operator in locations where it is not necessary and could be replaced by a series of expressions or statements.

var a,b,c;

a = 1, b = 1,  c= 3;

could just as well be written as:

var a,b,c;

a = 1;
b = 1;
c = 3;

To learn more about the sequence operator, please refer to the MDN.

Loading history...
219
  });
220
  var v = d._config.usePrefixes ? " -webkit- -moz- -o- -ms- ".split(" ") : ["", ""];
221
  d._prefixes = v;
222
  var m = d.testStyles = l;
223
  Modernizr.addTest("touchevents", function () {
0 ignored issues
show
Comprehensibility introduced by
Usage of the sequence operator is discouraged, since it may lead to obfuscated code.

The sequence or comma operator allows the inclusion of multiple expressions where only is permitted. The result of the sequence is the value of the last expression.

This operator is most often used in for statements.

Used in another places it can make code hard to read, especially when people do not realize it even exists as a seperate operator.

This check looks for usage of the sequence operator in locations where it is not necessary and could be replaced by a series of expressions or statements.

var a,b,c;

a = 1, b = 1,  c= 3;

could just as well be written as:

var a,b,c;

a = 1;
b = 1;
c = 3;

To learn more about the sequence operator, please refer to the MDN.

Loading history...
224
    var n;
225
    if ("ontouchstart" in e || e.DocumentTouch && t instanceof DocumentTouch) n = !0;else {
0 ignored issues
show
Coding Style Best Practice introduced by
Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

Consider adding curly braces around all statements when they are executed conditionally. This is optional if there is only one statement, but leaving them out can lead to unexpected behaviour if another statement is added later.

Consider:

if (a > 0)
    b = 42;

If you or someone else later decides to put another statement in, only the first statement will be executed.

if (a > 0)
    console.log("a > 0");
    b = 42;

In this case the statement b = 42 will always be executed, while the logging statement will be executed conditionally.

if (a > 0) {
    console.log("a > 0");
    b = 42;
}

ensures that the proper code will be executed conditionally no matter how many statements are added or removed.

Loading history...
Bug introduced by
The variable DocumentTouch seems to be never declared. If this is a global, consider adding a /** global: DocumentTouch */ comment.

This checks looks for references to variables that have not been declared. This is most likey a typographical error or a variable has been renamed.

To learn more about declaring variables in Javascript, see the MDN.

Loading history...
226
      var o = ["@media (", v.join("touch-enabled),("), "heartz", ")", "{#modernizr{top:9px;position:absolute}}"].join("");
227
      m(o, function (e) {
228
        n = 9 === e.offsetTop;
229
      });
230
    }
231
    return n;
0 ignored issues
show
Bug introduced by
The variable n seems to not be initialized for all possible execution paths.
Loading history...
232
  }), a(), s(f), delete d.addTest, delete d.addAsyncTest;
233
234
  for (var h = 0; h < Modernizr._q.length; h++) {
235
    Modernizr._q[h]();
236
  }
237
238
  e.Modernizr = Modernizr;
239
}(window, document);
240
241
/***/ }),
242
243
/***/ 3:
244
/*!************************************************!*\
245
  !*** multi ./resources/assets/js/modernizr.js ***!
246
  \************************************************/
247
/*! no static exports found */
248
/***/ (function(module, exports, __webpack_require__) {
249
250
module.exports = __webpack_require__(/*! C:\dev\TalentCloud\resources\assets\js\modernizr.js */"./resources/assets/js/modernizr.js");
251
252
253
/***/ })
254
255
/******/ });