Scrutinizer GitHub App not installed

We could not synchronize checks via GitHub's checks API since Scrutinizer's GitHub App is not installed for this repository.

Install GitHub App

Test Failed
Push — master ( ac126c...3e078a )
by Pierre
07:43
created

require.js ➔ ... ➔ checkLoaded   C

Complexity

Conditions 11
Paths 43

Size

Total Lines 86

Duplication

Lines 0
Ratio 0 %

Importance

Changes 1
Bugs 0 Features 0
Metric Value
cc 11
c 1
b 0
f 0
nc 43
nop 0
dl 0
loc 86
rs 5.2653

How to fix   Long Method    Complexity   

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:

Complexity

Complex classes like require.js ➔ ... ➔ checkLoaded often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

1
/** vim: et:ts=4:sw=4:sts=4
2
 * @license RequireJS 2.3.4 Copyright jQuery Foundation and other contributors.
3
 * Released under MIT license, https://github.com/requirejs/requirejs/blob/master/LICENSE
4
 */
5
//Not using strict: uneven strict support in browsers, #392, and causes
6
//problems with requirejs.exec()/transpiler plugins that may not be strict.
7
/*jslint regexp: true, nomen: true, sloppy: true */
8
/*global window, navigator, document, importScripts, setTimeout, opera */
9
10
var requirejs, require, define;
11
(function (global, setTimeout) {
12
    var req, s, head, baseElement, dataMain, src,
13
        interactiveScript, currentlyAddingScript, mainScript, subPath,
14
        version = '2.3.4',
15
        commentRegExp = /\/\*[\s\S]*?\*\/|([^:"'=]|^)\/\/.*$/mg,
16
        cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
17
        jsSuffixRegExp = /\.js$/,
18
        currDirRegExp = /^\.\//,
19
        op = Object.prototype,
20
        ostring = op.toString,
21
        hasOwn = op.hasOwnProperty,
22
        isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
23
        isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
24
        //PS3 indicates loaded and complete, but need to wait for complete
25
        //specifically. Sequence is 'loading', 'loaded', execution,
26
        // then 'complete'. The UA check is unfortunate, but not sure how
27
        //to feature test w/o causing perf issues.
28
        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
29
                      /^complete$/ : /^(complete|loaded)$/,
30
        defContextName = '_',
31
        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
32
        isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
33
        contexts = {},
34
        cfg = {},
35
        globalDefQueue = [],
36
        useInteractive = false;
37
38
    //Could match something like ')//comment', do not lose the prefix to comment.
39
    function commentReplace(match, singlePrefix) {
40
        return singlePrefix || '';
41
    }
42
43
    function isFunction(it) {
44
        return ostring.call(it) === '[object Function]';
45
    }
46
47
    function isArray(it) {
48
        return ostring.call(it) === '[object Array]';
49
    }
50
51
    /**
52
     * Helper function for iterating over an array. If the func returns
53
     * a true value, it will break out of the loop.
54
     */
55
    function each(ary, func) {
56
        if (ary) {
57
            var i;
58
            for (i = 0; i < ary.length; i += 1) {
59
                if (ary[i] && func(ary[i], i, ary)) {
60
                    break;
61
                }
62
            }
63
        }
64
    }
65
66
    /**
67
     * Helper function for iterating over an array backwards. If the func
68
     * returns a true value, it will break out of the loop.
69
     */
70
    function eachReverse(ary, func) {
71
        if (ary) {
72
            var i;
73
            for (i = ary.length - 1; i > -1; i -= 1) {
74
                if (ary[i] && func(ary[i], i, ary)) {
75
                    break;
76
                }
77
            }
78
        }
79
    }
80
81
    function hasProp(obj, prop) {
82
        return hasOwn.call(obj, prop);
83
    }
84
85
    function getOwn(obj, prop) {
86
        return hasProp(obj, prop) && obj[prop];
87
    }
88
89
    /**
90
     * Cycles over properties in an object and calls a function for each
91
     * property value. If the function returns a truthy value, then the
92
     * iteration is stopped.
93
     */
94
    function eachProp(obj, func) {
95
        var prop;
96
        for (prop in obj) {
97
            if (hasProp(obj, prop)) {
98
                if (func(obj[prop], prop)) {
99
                    break;
100
                }
101
            }
102
        }
103
    }
104
105
    /**
106
     * Simple function to mix in properties from source into target,
107
     * but only if target does not already have a property of the same name.
108
     */
109
    function mixin(target, source, force, deepStringMixin) {
110
        if (source) {
111
            eachProp(source, function (value, prop) {
112
                if (force || !hasProp(target, prop)) {
113
                    if (deepStringMixin && typeof value === 'object' && value &&
114
                        !isArray(value) && !isFunction(value) &&
115
                        !(value instanceof RegExp)) {
116
117
                        if (!target[prop]) {
118
                            target[prop] = {};
119
                        }
120
                        mixin(target[prop], value, force, deepStringMixin);
121
                    } else {
122
                        target[prop] = value;
123
                    }
124
                }
125
            });
126
        }
127
        return target;
128
    }
129
130
    //Similar to Function.prototype.bind, but the 'this' object is specified
131
    //first, since it is easier to read/figure out what 'this' will be.
132
    function bind(obj, fn) {
133
        return function () {
134
            return fn.apply(obj, arguments);
135
        };
136
    }
137
138
    function scripts() {
139
        return document.getElementsByTagName('script');
140
    }
141
142
    function defaultOnError(err) {
143
        throw err;
144
    }
145
146
    //Allow getting a global that is expressed in
147
    //dot notation, like 'a.b.c'.
148
    function getGlobal(value) {
149
        if (!value) {
150
            return value;
151
        }
152
        var g = global;
153
        each(value.split('.'), function (part) {
154
            g = g[part];
155
        });
156
        return g;
157
    }
158
159
    /**
160
     * Constructs an error with a pointer to an URL with more information.
161
     * @param {String} id the error ID that maps to an ID on a web page.
162
     * @param {String} message human readable error.
0 ignored issues
show
Documentation introduced by
The parameter message does not exist. Did you maybe forget to remove this comment?
Loading history...
163
     * @param {Error} [err] the original error, if there is one.
164
     *
165
     * @returns {Error}
166
     */
167
    function makeError(id, msg, err, requireModules) {
168
        var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
169
        e.requireType = id;
170
        e.requireModules = requireModules;
171
        if (err) {
172
            e.originalError = err;
173
        }
174
        return e;
175
    }
176
177
    if (typeof define !== 'undefined') {
178
        //If a define is already in play via another AMD loader,
179
        //do not overwrite.
180
        return;
181
    }
182
183
    if (typeof requirejs !== 'undefined') {
184
        if (isFunction(requirejs)) {
185
            //Do not overwrite an existing requirejs instance.
186
            return;
187
        }
188
        cfg = requirejs;
189
        requirejs = undefined;
190
    }
191
192
    //Allow for a require config object
193
    if (typeof require !== 'undefined' && !isFunction(require)) {
194
        //assume it is a config object.
195
        cfg = require;
196
        require = undefined;
197
    }
198
199
    function newContext(contextName) {
200
        var inCheckLoaded, Module, context, handlers,
201
            checkLoadedTimeoutId,
202
            config = {
203
                //Defaults. Do not set a default for map
204
                //config to speed up normalize(), which
205
                //will run faster if there is no default.
206
                waitSeconds: 7,
207
                baseUrl: './',
208
                paths: {},
209
                bundles: {},
210
                pkgs: {},
211
                shim: {},
212
                config: {}
213
            },
214
            registry = {},
215
            //registry of just enabled modules, to speed
216
            //cycle breaking code when lots of modules
217
            //are registered, but not activated.
218
            enabledRegistry = {},
219
            undefEvents = {},
220
            defQueue = [],
221
            defined = {},
222
            urlFetched = {},
223
            bundlesMap = {},
224
            requireCounter = 1,
225
            unnormalizedCounter = 1;
226
227
        /**
228
         * Trims the . and .. from an array of path segments.
229
         * It will keep a leading path segment if a .. will become
230
         * the first path segment, to help with module name lookups,
231
         * which act like paths, but can be remapped. But the end result,
232
         * all paths that use this function should look normalized.
233
         * NOTE: this method MODIFIES the input array.
234
         * @param {Array} ary the array of path segments.
235
         */
236
        function trimDots(ary) {
237
            var i, part;
238
            for (i = 0; i < ary.length; i++) {
239
                part = ary[i];
240
                if (part === '.') {
241
                    ary.splice(i, 1);
242
                    i -= 1;
243
                } else if (part === '..') {
244
                    // If at the start, or previous value is still ..,
245
                    // keep them so that when converted to a path it may
246
                    // still work when converted to a path, even though
247
                    // as an ID it is less than ideal. In larger point
248
                    // releases, may be better to just kick out an error.
249
                    if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
250
                        continue;
0 ignored issues
show
Unused Code introduced by
This continue has no effect on the loop flow and can be removed.
Loading history...
251
                    } else if (i > 0) {
252
                        ary.splice(i - 1, 2);
253
                        i -= 2;
254
                    }
255
                }
256
            }
257
        }
258
259
        /**
260
         * Given a relative module name, like ./something, normalize it to
261
         * a real name that can be mapped to a path.
262
         * @param {String} name the relative name
263
         * @param {String} baseName a real name that the name arg is relative
264
         * to.
265
         * @param {Boolean} applyMap apply the map config to the value. Should
266
         * only be done if this normalization is for a dependency ID.
267
         * @returns {String} normalized name
268
         */
269
        function normalize(name, baseName, applyMap) {
270
            var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
271
                foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
272
                baseParts = (baseName && baseName.split('/')),
273
                map = config.map,
274
                starMap = map && map['*'];
275
276
            //Adjust any relative paths.
277
            if (name) {
278
                name = name.split('/');
279
                lastIndex = name.length - 1;
280
281
                // If wanting node ID compatibility, strip .js from end
282
                // of IDs. Have to do this here, and not in nameToUrl
283
                // because node allows either .js or non .js to map
284
                // to same file.
285
                if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
286
                    name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
287
                }
288
289
                // Starts with a '.' so need the baseName
290
                if (name[0].charAt(0) === '.' && baseParts) {
291
                    //Convert baseName to array, and lop off the last part,
292
                    //so that . matches that 'directory' and not name of the baseName's
293
                    //module. For instance, baseName of 'one/two/three', maps to
294
                    //'one/two/three.js', but we want the directory, 'one/two' for
295
                    //this normalization.
296
                    normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
297
                    name = normalizedBaseParts.concat(name);
298
                }
299
300
                trimDots(name);
301
                name = name.join('/');
302
            }
303
304
            //Apply map config if available.
305
            if (applyMap && map && (baseParts || starMap)) {
306
                nameParts = name.split('/');
307
308
                outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
309
                    nameSegment = nameParts.slice(0, i).join('/');
310
311
                    if (baseParts) {
312
                        //Find the longest baseName segment match in the config.
313
                        //So, do joins on the biggest to smallest lengths of baseParts.
314
                        for (j = baseParts.length; j > 0; j -= 1) {
315
                            mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
316
317
                            //baseName segment has config, find if it has one for
318
                            //this name.
319
                            if (mapValue) {
320
                                mapValue = getOwn(mapValue, nameSegment);
321
                                if (mapValue) {
322
                                    //Match, update name to the new value.
323
                                    foundMap = mapValue;
324
                                    foundI = i;
325
                                    break outerLoop;
326
                                }
327
                            }
328
                        }
329
                    }
330
331
                    //Check for a star map match, but just hold on to it,
332
                    //if there is a shorter segment match later in a matching
333
                    //config, then favor over this star map.
334
                    if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
335
                        foundStarMap = getOwn(starMap, nameSegment);
336
                        starI = i;
337
                    }
338
                }
339
340
                if (!foundMap && foundStarMap) {
341
                    foundMap = foundStarMap;
342
                    foundI = starI;
0 ignored issues
show
Bug introduced by
The variable starI seems to not be initialized for all possible execution paths.
Loading history...
343
                }
344
345
                if (foundMap) {
346
                    nameParts.splice(0, foundI, foundMap);
0 ignored issues
show
Bug introduced by
The variable foundI seems to not be initialized for all possible execution paths. Are you sure splice handles undefined variables?
Loading history...
347
                    name = nameParts.join('/');
348
                }
349
            }
350
351
            // If the name points to a package's name, use
352
            // the package main instead.
353
            pkgMain = getOwn(config.pkgs, name);
354
355
            return pkgMain ? pkgMain : name;
356
        }
357
358
        function removeScript(name) {
359
            if (isBrowser) {
360
                each(scripts(), function (scriptNode) {
361
                    if (scriptNode.getAttribute('data-requiremodule') === name &&
0 ignored issues
show
Complexity Best Practice introduced by
There is no return statement if scriptNode.getAttribute(...=== context.contextName is false. Are you sure this is correct? If so, consider adding return; explicitly.

This check looks for functions where a return statement is found in some execution paths, but not in all.

Consider this little piece of code

function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

The function isBig will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return undefined.

This behaviour may not be what you had intended. In any case, you can add a return undefined to the other execution path to make the return value explicit.

Loading history...
362
                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
363
                        scriptNode.parentNode.removeChild(scriptNode);
364
                        return true;
365
                    }
366
                });
367
            }
368
        }
369
370
        function hasPathFallback(id) {
371
            var pathConfig = getOwn(config.paths, id);
372
            if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
0 ignored issues
show
Complexity Best Practice introduced by
There is no return statement if pathConfig && isArray(pa...& pathConfig.length > 1 is false. Are you sure this is correct? If so, consider adding return; explicitly.

This check looks for functions where a return statement is found in some execution paths, but not in all.

Consider this little piece of code

function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

The function isBig will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return undefined.

This behaviour may not be what you had intended. In any case, you can add a return undefined to the other execution path to make the return value explicit.

Loading history...
373
                //Pop off the first array value, since it failed, and
374
                //retry
375
                pathConfig.shift();
376
                context.require.undef(id);
377
378
                //Custom require that does not do map translation, since
379
                //ID is "absolute", already mapped/resolved.
380
                context.makeRequire(null, {
381
                    skipMap: true
382
                })([id]);
383
384
                return true;
385
            }
386
        }
387
388
        //Turns a plugin!resource to [plugin, resource]
389
        //with the plugin being undefined if the name
390
        //did not have a plugin prefix.
391
        function splitPrefix(name) {
392
            var prefix,
393
                index = name ? name.indexOf('!') : -1;
394
            if (index > -1) {
395
                prefix = name.substring(0, index);
396
                name = name.substring(index + 1, name.length);
397
            }
398
            return [prefix, name];
0 ignored issues
show
Bug introduced by
The variable prefix does not seem to be initialized in case index > -1 on line 394 is false. Are you sure this can never be the case?
Loading history...
399
        }
400
401
        /**
402
         * Creates a module mapping that includes plugin prefix, module
403
         * name, and path. If parentModuleMap is provided it will
404
         * also normalize the name via require.normalize()
405
         *
406
         * @param {String} name the module name
407
         * @param {String} [parentModuleMap] parent module map
408
         * for the module name, used to resolve relative names.
409
         * @param {Boolean} isNormalized: is the ID already normalized.
0 ignored issues
show
Documentation Bug introduced by
The parameter isNormalized: does not exist. Did you maybe mean isNormalized instead?
Loading history...
410
         * This is true if this call is done for a define() module ID.
411
         * @param {Boolean} applyMap: apply the map config to the ID.
0 ignored issues
show
Documentation Bug introduced by
The parameter applyMap: does not exist. Did you maybe mean applyMap instead?
Loading history...
412
         * Should only be true if this map is for a dependency.
413
         *
414
         * @returns {Object}
415
         */
416
        function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
417
            var url, pluginModule, suffix, nameParts,
418
                prefix = null,
0 ignored issues
show
Unused Code introduced by
The assignment to prefix seems to be never used. If you intend to free memory here, this is not necessary since the variable leaves the scope anyway.
Loading history...
419
                parentName = parentModuleMap ? parentModuleMap.name : null,
420
                originalName = name,
421
                isDefine = true,
422
                normalizedName = '';
423
424
            //If no name, then it means it is a require call, generate an
425
            //internal name.
426
            if (!name) {
427
                isDefine = false;
428
                name = '_@r' + (requireCounter += 1);
429
            }
430
431
            nameParts = splitPrefix(name);
432
            prefix = nameParts[0];
433
            name = nameParts[1];
434
435
            if (prefix) {
436
                prefix = normalize(prefix, parentName, applyMap);
437
                pluginModule = getOwn(defined, prefix);
438
            }
439
440
            //Account for relative paths if there is a base name.
441
            if (name) {
442
                if (prefix) {
443
                    if (isNormalized) {
444
                        normalizedName = name;
445
                    } else if (pluginModule && pluginModule.normalize) {
446
                        //Plugin is loaded, use its normalize method.
447
                        normalizedName = pluginModule.normalize(name, function (name) {
448
                            return normalize(name, parentName, applyMap);
449
                        });
450
                    } else {
451
                        // If nested plugin references, then do not try to
452
                        // normalize, as it will not normalize correctly. This
453
                        // places a restriction on resourceIds, and the longer
454
                        // term solution is not to normalize until plugins are
455
                        // loaded and all normalizations to allow for async
456
                        // loading of a loader plugin. But for now, fixes the
457
                        // common uses. Details in #1131
458
                        normalizedName = name.indexOf('!') === -1 ?
459
                                         normalize(name, parentName, applyMap) :
460
                                         name;
461
                    }
462
                } else {
463
                    //A regular module.
464
                    normalizedName = normalize(name, parentName, applyMap);
465
466
                    //Normalized name may be a plugin ID due to map config
467
                    //application in normalize. The map config values must
468
                    //already be normalized, so do not need to redo that part.
469
                    nameParts = splitPrefix(normalizedName);
470
                    prefix = nameParts[0];
471
                    normalizedName = nameParts[1];
472
                    isNormalized = true;
473
474
                    url = context.nameToUrl(normalizedName);
475
                }
476
            }
477
478
            //If the id is a plugin id that cannot be determined if it needs
479
            //normalization, stamp it with a unique ID so two matching relative
480
            //ids that may conflict can be separate.
481
            suffix = prefix && !pluginModule && !isNormalized ?
482
                     '_unnormalized' + (unnormalizedCounter += 1) :
483
                     '';
484
485
            return {
486
                prefix: prefix,
487
                name: normalizedName,
488
                parentMap: parentModuleMap,
489
                unnormalized: !!suffix,
490
                url: url,
0 ignored issues
show
Bug introduced by
The variable url seems to not be initialized for all possible execution paths.
Loading history...
491
                originalName: originalName,
492
                isDefine: isDefine,
493
                id: (prefix ?
494
                        prefix + '!' + normalizedName :
495
                        normalizedName) + suffix
496
            };
497
        }
498
499
        function getModule(depMap) {
500
            var id = depMap.id,
501
                mod = getOwn(registry, id);
502
503
            if (!mod) {
504
                mod = registry[id] = new context.Module(depMap);
505
            }
506
507
            return mod;
508
        }
509
510
        function on(depMap, name, fn) {
511
            var id = depMap.id,
512
                mod = getOwn(registry, id);
513
514
            if (hasProp(defined, id) &&
515
                    (!mod || mod.defineEmitComplete)) {
516
                if (name === 'defined') {
517
                    fn(defined[id]);
518
                }
519
            } else {
520
                mod = getModule(depMap);
521
                if (mod.error && name === 'error') {
522
                    fn(mod.error);
523
                } else {
524
                    mod.on(name, fn);
525
                }
526
            }
527
        }
528
529
        function onError(err, errback) {
530
            var ids = err.requireModules,
531
                notified = false;
532
533
            if (errback) {
534
                errback(err);
535
            } else {
536
                each(ids, function (id) {
537
                    var mod = getOwn(registry, id);
538
                    if (mod) {
539
                        //Set error on module, so it skips timeout checks.
540
                        mod.error = err;
541
                        if (mod.events.error) {
542
                            notified = true;
543
                            mod.emit('error', err);
544
                        }
545
                    }
546
                });
547
548
                if (!notified) {
549
                    req.onError(err);
550
                }
551
            }
552
        }
553
554
        /**
555
         * Internal method to transfer globalQueue items to this context's
556
         * defQueue.
557
         */
558
        function takeGlobalQueue() {
559
            //Push all the globalDefQueue items into the context's defQueue
560
            if (globalDefQueue.length) {
561
                each(globalDefQueue, function(queueItem) {
562
                    var id = queueItem[0];
563
                    if (typeof id === 'string') {
564
                        context.defQueueMap[id] = true;
565
                    }
566
                    defQueue.push(queueItem);
567
                });
568
                globalDefQueue = [];
569
            }
570
        }
571
572
        handlers = {
573
            'require': function (mod) {
574
                if (mod.require) {
575
                    return mod.require;
576
                } else {
577
                    return (mod.require = context.makeRequire(mod.map));
578
                }
579
            },
580
            'exports': function (mod) {
581
                mod.usingExports = true;
582
                if (mod.map.isDefine) {
0 ignored issues
show
Complexity Best Practice introduced by
There is no return statement if mod.map.isDefine is false. Are you sure this is correct? If so, consider adding return; explicitly.

This check looks for functions where a return statement is found in some execution paths, but not in all.

Consider this little piece of code

function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

The function isBig will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return undefined.

This behaviour may not be what you had intended. In any case, you can add a return undefined to the other execution path to make the return value explicit.

Loading history...
583
                    if (mod.exports) {
584
                        return (defined[mod.map.id] = mod.exports);
585
                    } else {
586
                        return (mod.exports = defined[mod.map.id] = {});
587
                    }
588
                }
589
            },
590
            'module': function (mod) {
591
                if (mod.module) {
592
                    return mod.module;
593
                } else {
594
                    return (mod.module = {
595
                        id: mod.map.id,
596
                        uri: mod.map.url,
597
                        config: function () {
598
                            return getOwn(config.config, mod.map.id) || {};
599
                        },
600
                        exports: mod.exports || (mod.exports = {})
601
                    });
602
                }
603
            }
604
        };
605
606
        function cleanRegistry(id) {
607
            //Clean up machinery used for waiting modules.
608
            delete registry[id];
609
            delete enabledRegistry[id];
610
        }
611
612
        function breakCycle(mod, traced, processed) {
613
            var id = mod.map.id;
614
615
            if (mod.error) {
616
                mod.emit('error', mod.error);
617
            } else {
618
                traced[id] = true;
619
                each(mod.depMaps, function (depMap, i) {
620
                    var depId = depMap.id,
621
                        dep = getOwn(registry, depId);
622
623
                    //Only force things that have not completed
624
                    //being defined, so still in the registry,
625
                    //and only if it has not been matched up
626
                    //in the module already.
627
                    if (dep && !mod.depMatched[i] && !processed[depId]) {
628
                        if (getOwn(traced, depId)) {
629
                            mod.defineDep(i, defined[depId]);
630
                            mod.check(); //pass false?
631
                        } else {
632
                            breakCycle(dep, traced, processed);
633
                        }
634
                    }
635
                });
636
                processed[id] = true;
637
            }
638
        }
639
640
        function checkLoaded() {
641
            var err, usingPathFallback,
642
                waitInterval = config.waitSeconds * 1000,
643
                //It is possible to disable the wait interval by using waitSeconds of 0.
644
                expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
645
                noLoads = [],
646
                reqCalls = [],
647
                stillLoading = false,
648
                needCycleCheck = true;
649
650
            //Do not bother if this call was a result of a cycle break.
651
            if (inCheckLoaded) {
652
                return;
653
            }
654
655
            inCheckLoaded = true;
656
657
            //Figure out the state of all the modules.
658
            eachProp(enabledRegistry, function (mod) {
659
                var map = mod.map,
660
                    modId = map.id;
661
662
                //Skip things that are not enabled or in error state.
663
                if (!mod.enabled) {
664
                    return;
665
                }
666
667
                if (!map.isDefine) {
668
                    reqCalls.push(mod);
669
                }
670
671
                if (!mod.error) {
0 ignored issues
show
Complexity Best Practice introduced by
There is no return statement if !mod.error is false. Are you sure this is correct? If so, consider adding return; explicitly.

This check looks for functions where a return statement is found in some execution paths, but not in all.

Consider this little piece of code

function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

The function isBig will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return undefined.

This behaviour may not be what you had intended. In any case, you can add a return undefined to the other execution path to make the return value explicit.

Loading history...
672
                    //If the module should be executed, and it has not
673
                    //been inited and time is up, remember it.
674
                    if (!mod.inited && expired) {
675
                        if (hasPathFallback(modId)) {
676
                            usingPathFallback = true;
677
                            stillLoading = true;
0 ignored issues
show
Best Practice introduced by
There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.
Loading history...
678
                        } else {
679
                            noLoads.push(modId);
680
                            removeScript(modId);
0 ignored issues
show
Best Practice introduced by
There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.
Loading history...
681
                        }
682
                    } else if (!mod.inited && mod.fetched && map.isDefine) {
0 ignored issues
show
Complexity Best Practice introduced by
There is no return statement if !mod.inited && mod.fetched && map.isDefine is false. Are you sure this is correct? If so, consider adding return; explicitly.

This check looks for functions where a return statement is found in some execution paths, but not in all.

Consider this little piece of code

function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

The function isBig will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return undefined.

This behaviour may not be what you had intended. In any case, you can add a return undefined to the other execution path to make the return value explicit.

Loading history...
683
                        stillLoading = true;
684
                        if (!map.prefix) {
0 ignored issues
show
Complexity Best Practice introduced by
There is no return statement if !map.prefix is false. Are you sure this is correct? If so, consider adding return; explicitly.

This check looks for functions where a return statement is found in some execution paths, but not in all.

Consider this little piece of code

function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

The function isBig will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return undefined.

This behaviour may not be what you had intended. In any case, you can add a return undefined to the other execution path to make the return value explicit.

Loading history...
685
                            //No reason to keep looking for unfinished
686
                            //loading. If the only stillLoading is a
687
                            //plugin resource though, keep going,
688
                            //because it may be that a plugin resource
689
                            //is waiting on a non-plugin cycle.
690
                            return (needCycleCheck = false);
691
                        }
692
                    }
693
                }
694
            });
695
696
            if (expired && noLoads.length) {
697
                //If wait time expired, throw error of unloaded modules.
698
                err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
699
                err.contextName = context.contextName;
700
                return onError(err);
701
            }
702
703
            //Not expired, check for a cycle.
704
            if (needCycleCheck) {
705
                each(reqCalls, function (mod) {
706
                    breakCycle(mod, {}, {});
707
                });
708
            }
709
710
            //If still waiting on loads, and the waiting load is something
711
            //other than a plugin resource, or there are still outstanding
712
            //scripts, then just try back later.
713
            if ((!expired || usingPathFallback) && stillLoading) {
714
                //Something is still waiting to load. Wait for it, but only
715
                //if a timeout is not already in effect.
716
                if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
717
                    checkLoadedTimeoutId = setTimeout(function () {
718
                        checkLoadedTimeoutId = 0;
719
                        checkLoaded();
720
                    }, 50);
721
                }
722
            }
723
724
            inCheckLoaded = false;
0 ignored issues
show
Best Practice introduced by
There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.
Loading history...
725
        }
726
727
        Module = function (map) {
728
            this.events = getOwn(undefEvents, map.id) || {};
729
            this.map = map;
730
            this.shim = getOwn(config.shim, map.id);
731
            this.depExports = [];
732
            this.depMaps = [];
733
            this.depMatched = [];
734
            this.pluginMaps = {};
735
            this.depCount = 0;
736
737
            /* this.exports this.factory
738
               this.depMaps = [],
739
               this.enabled, this.fetched
740
            */
741
        };
742
743
        Module.prototype = {
744
            init: function (depMaps, factory, errback, options) {
745
                options = options || {};
746
747
                //Do not do more inits if already done. Can happen if there
748
                //are multiple define calls for the same module. That is not
749
                //a normal, common case, but it is also not unexpected.
750
                if (this.inited) {
751
                    return;
752
                }
753
754
                this.factory = factory;
755
756
                if (errback) {
757
                    //Register for errors on this module.
758
                    this.on('error', errback);
759
                } else if (this.events.error) {
760
                    //If no errback already, but there are error listeners
761
                    //on this module, set up an errback to pass to the deps.
762
                    errback = bind(this, function (err) {
763
                        this.emit('error', err);
764
                    });
765
                }
766
767
                //Do a copy of the dependency array, so that
768
                //source inputs are not modified. For example
769
                //"shim" deps are passed in here directly, and
770
                //doing a direct modification of the depMaps array
771
                //would affect that config.
772
                this.depMaps = depMaps && depMaps.slice(0);
773
774
                this.errback = errback;
775
776
                //Indicate this module has be initialized
777
                this.inited = true;
778
779
                this.ignore = options.ignore;
780
781
                //Could have option to init this module in enabled mode,
782
                //or could have been previously marked as enabled. However,
783
                //the dependencies are not known until init is called. So
784
                //if enabled previously, now trigger dependencies as enabled.
785
                if (options.enabled || this.enabled) {
786
                    //Enable this module and dependencies.
787
                    //Will call this.check()
788
                    this.enable();
789
                } else {
790
                    this.check();
791
                }
792
            },
793
794
            defineDep: function (i, depExports) {
795
                //Because of cycles, defined callback for a given
796
                //export can be called more than once.
797
                if (!this.depMatched[i]) {
798
                    this.depMatched[i] = true;
799
                    this.depCount -= 1;
800
                    this.depExports[i] = depExports;
801
                }
802
            },
803
804
            fetch: function () {
805
                if (this.fetched) {
806
                    return;
807
                }
808
                this.fetched = true;
809
810
                context.startTime = (new Date()).getTime();
811
812
                var map = this.map;
813
814
                //If the manager is for a plugin managed resource,
815
                //ask the plugin to load it now.
816
                if (this.shim) {
817
                    context.makeRequire(this.map, {
818
                        enableBuildCallback: true
819
                    })(this.shim.deps || [], bind(this, function () {
820
                        return map.prefix ? this.callPlugin() : this.load();
821
                    }));
0 ignored issues
show
Best Practice introduced by
There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.
Loading history...
822
                } else {
823
                    //Regular dependency.
824
                    return map.prefix ? this.callPlugin() : this.load();
825
                }
826
            },
827
828
            load: function () {
829
                var url = this.map.url;
830
831
                //Regular dependency.
832
                if (!urlFetched[url]) {
833
                    urlFetched[url] = true;
834
                    context.load(this.map.id, url);
835
                }
836
            },
837
838
            /**
839
             * Checks if the module is ready to define itself, and if so,
840
             * define it.
841
             */
842
            check: function () {
843
                if (!this.enabled || this.enabling) {
844
                    return;
845
                }
846
847
                var err, cjsModule,
848
                    id = this.map.id,
849
                    depExports = this.depExports,
850
                    exports = this.exports,
851
                    factory = this.factory;
852
853
                if (!this.inited) {
854
                    // Only fetch if not already in the defQueue.
855
                    if (!hasProp(context.defQueueMap, id)) {
0 ignored issues
show
Complexity Best Practice introduced by
There is no return statement if !hasProp(context.defQueueMap, id) is false. Are you sure this is correct? If so, consider adding return; explicitly.

This check looks for functions where a return statement is found in some execution paths, but not in all.

Consider this little piece of code

function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

The function isBig will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return undefined.

This behaviour may not be what you had intended. In any case, you can add a return undefined to the other execution path to make the return value explicit.

Loading history...
856
                        this.fetch();
0 ignored issues
show
Best Practice introduced by
There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.
Loading history...
857
                    }
858
                } else if (this.error) {
859
                    this.emit('error', this.error);
0 ignored issues
show
Best Practice introduced by
There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.
Loading history...
860
                } else if (!this.defining) {
0 ignored issues
show
Complexity Best Practice introduced by
There is no return statement if !this.defining is false. Are you sure this is correct? If so, consider adding return; explicitly.

This check looks for functions where a return statement is found in some execution paths, but not in all.

Consider this little piece of code

function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

The function isBig will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return undefined.

This behaviour may not be what you had intended. In any case, you can add a return undefined to the other execution path to make the return value explicit.

Loading history...
861
                    //The factory could trigger another require call
862
                    //that would result in checking this module to
863
                    //define itself again. If already in the process
864
                    //of doing that, skip this work.
865
                    this.defining = true;
866
867
                    if (this.depCount < 1 && !this.defined) {
868
                        if (isFunction(factory)) {
869
                            //If there is an error listener, favor passing
870
                            //to that instead of throwing an error. However,
871
                            //only do it for define()'d  modules. require
872
                            //errbacks should not be called for failures in
873
                            //their callbacks (#699). However if a global
874
                            //onError is set, use that.
875
                            if ((this.events.error && this.map.isDefine) ||
876
                                req.onError !== defaultOnError) {
877
                                try {
878
                                    exports = context.execCb(id, factory, depExports, exports);
879
                                } catch (e) {
880
                                    err = e;
881
                                }
882
                            } else {
883
                                exports = context.execCb(id, factory, depExports, exports);
884
                            }
885
886
                            // Favor return value over exports. If node/cjs in play,
887
                            // then will not have a return value anyway. Favor
888
                            // module.exports assignment over exports object.
889
                            if (this.map.isDefine && exports === undefined) {
890
                                cjsModule = this.module;
891
                                if (cjsModule) {
892
                                    exports = cjsModule.exports;
893
                                } else if (this.usingExports) {
894
                                    //exports already set the defined value.
895
                                    exports = this.exports;
896
                                }
897
                            }
898
899
                            if (err) {
900
                                err.requireMap = this.map;
901
                                err.requireModules = this.map.isDefine ? [this.map.id] : null;
902
                                err.requireType = this.map.isDefine ? 'define' : 'require';
903
                                return onError((this.error = err));
904
                            }
905
906
                        } else {
907
                            //Just a literal value
908
                            exports = factory;
909
                        }
910
911
                        this.exports = exports;
912
913
                        if (this.map.isDefine && !this.ignore) {
914
                            defined[id] = exports;
915
916
                            if (req.onResourceLoad) {
917
                                var resLoadMaps = [];
918
                                each(this.depMaps, function (depMap) {
919
                                    resLoadMaps.push(depMap.normalizedMap || depMap);
920
                                });
921
                                req.onResourceLoad(context, this.map, resLoadMaps);
922
                            }
923
                        }
924
925
                        //Clean up
926
                        cleanRegistry(id);
927
928
                        this.defined = true;
929
                    }
930
931
                    //Finished the define stage. Allow calling check again
932
                    //to allow define notifications below in the case of a
933
                    //cycle.
934
                    this.defining = false;
935
936
                    if (this.defined && !this.defineEmitted) {
0 ignored issues
show
Complexity Best Practice introduced by
There is no return statement if this.defined && !this.defineEmitted is false. Are you sure this is correct? If so, consider adding return; explicitly.

This check looks for functions where a return statement is found in some execution paths, but not in all.

Consider this little piece of code

function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

The function isBig will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return undefined.

This behaviour may not be what you had intended. In any case, you can add a return undefined to the other execution path to make the return value explicit.

Loading history...
937
                        this.defineEmitted = true;
938
                        this.emit('defined', this.exports);
939
                        this.defineEmitComplete = true;
0 ignored issues
show
Best Practice introduced by
There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.
Loading history...
940
                    }
941
942
                }
943
            },
944
945
            callPlugin: function () {
946
                var map = this.map,
947
                    id = map.id,
948
                    //Map already normalized the prefix.
949
                    pluginMap = makeModuleMap(map.prefix);
950
951
                //Mark this as a dependency for this plugin, so it
952
                //can be traced for cycles.
953
                this.depMaps.push(pluginMap);
954
955
                on(pluginMap, 'defined', bind(this, function (plugin) {
956
                    var load, normalizedMap, normalizedMod,
957
                        bundleId = getOwn(bundlesMap, this.map.id),
958
                        name = this.map.name,
959
                        parentName = this.map.parentMap ? this.map.parentMap.name : null,
960
                        localRequire = context.makeRequire(map.parentMap, {
961
                            enableBuildCallback: true
962
                        });
963
964
                    //If current map is not normalized, wait for that
965
                    //normalized name to load instead of continuing.
966
                    if (this.map.unnormalized) {
967
                        //Normalize the ID if the plugin allows it.
968
                        if (plugin.normalize) {
969
                            name = plugin.normalize(name, function (name) {
970
                                return normalize(name, parentName, true);
971
                            }) || '';
972
                        }
973
974
                        //prefix and name should already be normalized, no need
975
                        //for applying map config again either.
976
                        normalizedMap = makeModuleMap(map.prefix + '!' + name,
977
                                                      this.map.parentMap,
978
                                                      true);
979
                        on(normalizedMap,
980
                            'defined', bind(this, function (value) {
981
                                this.map.normalizedMap = normalizedMap;
982
                                this.init([], function () { return value; }, null, {
983
                                    enabled: true,
984
                                    ignore: true
985
                                });
986
                            }));
987
988
                        normalizedMod = getOwn(registry, normalizedMap.id);
989
                        if (normalizedMod) {
990
                            //Mark this as a dependency for this plugin, so it
991
                            //can be traced for cycles.
992
                            this.depMaps.push(normalizedMap);
993
994
                            if (this.events.error) {
995
                                normalizedMod.on('error', bind(this, function (err) {
996
                                    this.emit('error', err);
997
                                }));
998
                            }
999
                            normalizedMod.enable();
1000
                        }
1001
1002
                        return;
1003
                    }
1004
1005
                    //If a paths config, then just load that file instead to
1006
                    //resolve the plugin, as it is built into that paths layer.
1007
                    if (bundleId) {
1008
                        this.map.url = context.nameToUrl(bundleId);
1009
                        this.load();
1010
                        return;
1011
                    }
1012
1013
                    load = bind(this, function (value) {
1014
                        this.init([], function () { return value; }, null, {
1015
                            enabled: true
1016
                        });
1017
                    });
1018
1019
                    load.error = bind(this, function (err) {
1020
                        this.inited = true;
1021
                        this.error = err;
1022
                        err.requireModules = [id];
1023
1024
                        //Remove temp unnormalized modules for this module,
1025
                        //since they will never be resolved otherwise now.
1026
                        eachProp(registry, function (mod) {
1027
                            if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
1028
                                cleanRegistry(mod.map.id);
1029
                            }
1030
                        });
1031
1032
                        onError(err);
1033
                    });
1034
1035
                    //Allow plugins to load other code without having to know the
1036
                    //context or how to 'complete' the load.
1037
                    load.fromText = bind(this, function (text, textAlt) {
1038
                        /*jslint evil: true */
1039
                        var moduleName = map.name,
1040
                            moduleMap = makeModuleMap(moduleName),
1041
                            hasInteractive = useInteractive;
1042
1043
                        //As of 2.1.0, support just passing the text, to reinforce
1044
                        //fromText only being called once per resource. Still
1045
                        //support old style of passing moduleName but discard
1046
                        //that moduleName in favor of the internal ref.
1047
                        if (textAlt) {
1048
                            text = textAlt;
1049
                        }
1050
1051
                        //Turn off interactive script matching for IE for any define
1052
                        //calls in the text, then turn it back on at the end.
1053
                        if (hasInteractive) {
1054
                            useInteractive = false;
1055
                        }
1056
1057
                        //Prime the system by creating a module instance for
1058
                        //it.
1059
                        getModule(moduleMap);
1060
1061
                        //Transfer any config to this other module.
1062
                        if (hasProp(config.config, id)) {
1063
                            config.config[moduleName] = config.config[id];
1064
                        }
1065
1066
                        try {
1067
                            req.exec(text);
1068
                        } catch (e) {
1069
                            return onError(makeError('fromtexteval',
1070
                                             'fromText eval for ' + id +
1071
                                            ' failed: ' + e,
1072
                                             e,
1073
                                             [id]));
1074
                        }
1075
1076
                        if (hasInteractive) {
1077
                            useInteractive = true;
1078
                        }
1079
1080
                        //Mark this as a dependency for the plugin
1081
                        //resource
1082
                        this.depMaps.push(moduleMap);
1083
1084
                        //Support anonymous modules.
1085
                        context.completeLoad(moduleName);
1086
1087
                        //Bind the value of that module to the value for this
1088
                        //resource ID.
1089
                        localRequire([moduleName], load);
0 ignored issues
show
Best Practice introduced by
There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.
Loading history...
1090
                    });
1091
1092
                    //Use parentName here since the plugin's name is not reliable,
1093
                    //could be some weird string with no path that actually wants to
1094
                    //reference the parentName's path.
1095
                    plugin.load(map.name, localRequire, load, config);
1096
                }));
1097
1098
                context.enable(pluginMap, this);
1099
                this.pluginMaps[pluginMap.id] = pluginMap;
1100
            },
1101
1102
            enable: function () {
1103
                enabledRegistry[this.map.id] = this;
1104
                this.enabled = true;
1105
1106
                //Set flag mentioning that the module is enabling,
1107
                //so that immediate calls to the defined callbacks
1108
                //for dependencies do not trigger inadvertent load
1109
                //with the depCount still being zero.
1110
                this.enabling = true;
1111
1112
                //Enable each dependency
1113
                each(this.depMaps, bind(this, function (depMap, i) {
1114
                    var id, mod, handler;
1115
1116
                    if (typeof depMap === 'string') {
1117
                        //Dependency needs to be converted to a depMap
1118
                        //and wired up to this module.
1119
                        depMap = makeModuleMap(depMap,
1120
                                               (this.map.isDefine ? this.map : this.map.parentMap),
1121
                                               false,
1122
                                               !this.skipMap);
1123
                        this.depMaps[i] = depMap;
1124
1125
                        handler = getOwn(handlers, depMap.id);
1126
1127
                        if (handler) {
1128
                            this.depExports[i] = handler(this);
1129
                            return;
1130
                        }
1131
1132
                        this.depCount += 1;
1133
1134
                        on(depMap, 'defined', bind(this, function (depExports) {
1135
                            if (this.undefed) {
1136
                                return;
1137
                            }
1138
                            this.defineDep(i, depExports);
1139
                            this.check();
1140
                        }));
1141
1142
                        if (this.errback) {
1143
                            on(depMap, 'error', bind(this, this.errback));
1144
                        } else if (this.events.error) {
1145
                            // No direct errback on this module, but something
1146
                            // else is listening for errors, so be sure to
1147
                            // propagate the error correctly.
1148
                            on(depMap, 'error', bind(this, function(err) {
1149
                                this.emit('error', err);
1150
                            }));
1151
                        }
1152
                    }
1153
1154
                    id = depMap.id;
1155
                    mod = registry[id];
1156
1157
                    //Skip special modules like 'require', 'exports', 'module'
1158
                    //Also, don't call enable if it is already enabled,
1159
                    //important in circular dependency cases.
1160
                    if (!hasProp(handlers, id) && mod && !mod.enabled) {
1161
                        context.enable(depMap, this);
1162
                    }
1163
                }));
1164
1165
                //Enable each plugin that is used in
1166
                //a dependency
1167
                eachProp(this.pluginMaps, bind(this, function (pluginMap) {
1168
                    var mod = getOwn(registry, pluginMap.id);
1169
                    if (mod && !mod.enabled) {
1170
                        context.enable(pluginMap, this);
1171
                    }
1172
                }));
1173
1174
                this.enabling = false;
1175
1176
                this.check();
1177
            },
1178
1179
            on: function (name, cb) {
1180
                var cbs = this.events[name];
1181
                if (!cbs) {
1182
                    cbs = this.events[name] = [];
1183
                }
1184
                cbs.push(cb);
1185
            },
1186
1187
            emit: function (name, evt) {
1188
                each(this.events[name], function (cb) {
1189
                    cb(evt);
1190
                });
1191
                if (name === 'error') {
1192
                    //Now that the error handler was triggered, remove
1193
                    //the listeners, since this broken Module instance
1194
                    //can stay around for a while in the registry.
1195
                    delete this.events[name];
1196
                }
1197
            }
1198
        };
1199
1200
        function callGetModule(args) {
1201
            //Skip modules already defined.
1202
            if (!hasProp(defined, args[0])) {
1203
                getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
1204
            }
1205
        }
1206
1207
        function removeListener(node, func, name, ieName) {
1208
            //Favor detachEvent because of IE9
1209
            //issue, see attachEvent/addEventListener comment elsewhere
1210
            //in this file.
1211
            if (node.detachEvent && !isOpera) {
1212
                //Probably IE. If not it will throw an error, which will be
1213
                //useful to know.
1214
                if (ieName) {
1215
                    node.detachEvent(ieName, func);
1216
                }
1217
            } else {
1218
                node.removeEventListener(name, func, false);
1219
            }
1220
        }
1221
1222
        /**
1223
         * Given an event from a script node, get the requirejs info from it,
1224
         * and then removes the event listeners on the node.
1225
         * @param {Event} evt
1226
         * @returns {Object}
1227
         */
1228
        function getScriptData(evt) {
1229
            //Using currentTarget instead of target for Firefox 2.0's sake. Not
1230
            //all old browsers will be supported, but this one was easy enough
1231
            //to support and still makes sense.
1232
            var node = evt.currentTarget || evt.srcElement;
1233
1234
            //Remove the listeners once here.
1235
            removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
1236
            removeListener(node, context.onScriptError, 'error');
1237
1238
            return {
1239
                node: node,
1240
                id: node && node.getAttribute('data-requiremodule')
1241
            };
1242
        }
1243
1244
        function intakeDefines() {
1245
            var args;
1246
1247
            //Any defined modules in the global queue, intake them now.
1248
            takeGlobalQueue();
1249
1250
            //Make sure any remaining defQueue items get properly processed.
1251
            while (defQueue.length) {
1252
                args = defQueue.shift();
1253
                if (args[0] === null) {
1254
                    return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' +
1255
                        args[args.length - 1]));
1256
                } else {
1257
                    //args are id, deps, factory. Should be normalized by the
1258
                    //define() function.
1259
                    callGetModule(args);
1260
                }
1261
            }
1262
            context.defQueueMap = {};
0 ignored issues
show
Best Practice introduced by
There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.
Loading history...
1263
        }
1264
1265
        context = {
1266
            config: config,
1267
            contextName: contextName,
1268
            registry: registry,
1269
            defined: defined,
1270
            urlFetched: urlFetched,
1271
            defQueue: defQueue,
1272
            defQueueMap: {},
1273
            Module: Module,
1274
            makeModuleMap: makeModuleMap,
1275
            nextTick: req.nextTick,
1276
            onError: onError,
1277
1278
            /**
1279
             * Set a configuration for the context.
1280
             * @param {Object} cfg config object to integrate.
1281
             */
1282
            configure: function (cfg) {
1283
                //Make sure the baseUrl ends in a slash.
1284
                if (cfg.baseUrl) {
1285
                    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
1286
                        cfg.baseUrl += '/';
1287
                    }
1288
                }
1289
1290
                // Convert old style urlArgs string to a function.
1291
                if (typeof cfg.urlArgs === 'string') {
1292
                    var urlArgs = cfg.urlArgs;
1293
                    cfg.urlArgs = function(id, url) {
1294
                        return (url.indexOf('?') === -1 ? '?' : '&') + urlArgs;
1295
                    };
1296
                }
1297
1298
                //Save off the paths since they require special processing,
1299
                //they are additive.
1300
                var shim = config.shim,
1301
                    objs = {
1302
                        paths: true,
1303
                        bundles: true,
1304
                        config: true,
1305
                        map: true
1306
                    };
1307
1308
                eachProp(cfg, function (value, prop) {
1309
                    if (objs[prop]) {
1310
                        if (!config[prop]) {
1311
                            config[prop] = {};
1312
                        }
1313
                        mixin(config[prop], value, true, true);
1314
                    } else {
1315
                        config[prop] = value;
1316
                    }
1317
                });
1318
1319
                //Reverse map the bundles
1320
                if (cfg.bundles) {
1321
                    eachProp(cfg.bundles, function (value, prop) {
1322
                        each(value, function (v) {
1323
                            if (v !== prop) {
1324
                                bundlesMap[v] = prop;
1325
                            }
1326
                        });
1327
                    });
1328
                }
1329
1330
                //Merge shim
1331
                if (cfg.shim) {
1332
                    eachProp(cfg.shim, function (value, id) {
1333
                        //Normalize the structure
1334
                        if (isArray(value)) {
1335
                            value = {
1336
                                deps: value
1337
                            };
1338
                        }
1339
                        if ((value.exports || value.init) && !value.exportsFn) {
1340
                            value.exportsFn = context.makeShimExports(value);
1341
                        }
1342
                        shim[id] = value;
1343
                    });
1344
                    config.shim = shim;
1345
                }
1346
1347
                //Adjust packages if necessary.
1348
                if (cfg.packages) {
1349
                    each(cfg.packages, function (pkgObj) {
1350
                        var location, name;
1351
1352
                        pkgObj = typeof pkgObj === 'string' ? {name: pkgObj} : pkgObj;
1353
1354
                        name = pkgObj.name;
1355
                        location = pkgObj.location;
1356
                        if (location) {
1357
                            config.paths[name] = pkgObj.location;
1358
                        }
1359
1360
                        //Save pointer to main module ID for pkg name.
1361
                        //Remove leading dot in main, so main paths are normalized,
1362
                        //and remove any trailing .js, since different package
1363
                        //envs have different conventions: some use a module name,
1364
                        //some use a file name.
1365
                        config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
1366
                                     .replace(currDirRegExp, '')
1367
                                     .replace(jsSuffixRegExp, '');
1368
                    });
1369
                }
1370
1371
                //If there are any "waiting to execute" modules in the registry,
1372
                //update the maps for them, since their info, like URLs to load,
1373
                //may have changed.
1374
                eachProp(registry, function (mod, id) {
1375
                    //If module already has init called, since it is too
1376
                    //late to modify them, and ignore unnormalized ones
1377
                    //since they are transient.
1378
                    if (!mod.inited && !mod.map.unnormalized) {
1379
                        mod.map = makeModuleMap(id, null, true);
1380
                    }
1381
                });
1382
1383
                //If a deps array or a config callback is specified, then call
1384
                //require with those args. This is useful when require is defined as a
1385
                //config object before require.js is loaded.
1386
                if (cfg.deps || cfg.callback) {
1387
                    context.require(cfg.deps || [], cfg.callback);
1388
                }
1389
            },
1390
1391
            makeShimExports: function (value) {
1392
                function fn() {
1393
                    var ret;
1394
                    if (value.init) {
1395
                        ret = value.init.apply(global, arguments);
1396
                    }
1397
                    return ret || (value.exports && getGlobal(value.exports));
1398
                }
1399
                return fn;
1400
            },
1401
1402
            makeRequire: function (relMap, options) {
1403
                options = options || {};
1404
1405
                function localRequire(deps, callback, errback) {
1406
                    var id, map, requireMod;
1407
1408
                    if (options.enableBuildCallback && callback && isFunction(callback)) {
1409
                        callback.__requireJsBuild = true;
1410
                    }
1411
1412
                    if (typeof deps === 'string') {
1413
                        if (isFunction(callback)) {
1414
                            //Invalid call
1415
                            return onError(makeError('requireargs', 'Invalid require call'), errback);
1416
                        }
1417
1418
                        //If require|exports|module are requested, get the
1419
                        //value for them from the special handlers. Caveat:
1420
                        //this only works while module is being defined.
1421
                        if (relMap && hasProp(handlers, deps)) {
1422
                            return handlers[deps](registry[relMap.id]);
1423
                        }
1424
1425
                        //Synchronous access to one module. If require.get is
1426
                        //available (as in the Node adapter), prefer that.
1427
                        if (req.get) {
1428
                            return req.get(context, deps, relMap, localRequire);
1429
                        }
1430
1431
                        //Normalize module name, if it contains . or ..
1432
                        map = makeModuleMap(deps, relMap, false, true);
1433
                        id = map.id;
1434
1435
                        if (!hasProp(defined, id)) {
1436
                            return onError(makeError('notloaded', 'Module name "' +
1437
                                        id +
1438
                                        '" has not been loaded yet for context: ' +
1439
                                        contextName +
1440
                                        (relMap ? '' : '. Use require([])')));
1441
                        }
1442
                        return defined[id];
1443
                    }
1444
1445
                    //Grab defines waiting in the global queue.
1446
                    intakeDefines();
1447
1448
                    //Mark all the dependencies as needing to be loaded.
1449
                    context.nextTick(function () {
1450
                        //Some defines could have been added since the
1451
                        //require call, collect them.
1452
                        intakeDefines();
1453
1454
                        requireMod = getModule(makeModuleMap(null, relMap));
1455
1456
                        //Store if map config should be applied to this require
1457
                        //call for dependencies.
1458
                        requireMod.skipMap = options.skipMap;
1459
1460
                        requireMod.init(deps, callback, errback, {
1461
                            enabled: true
1462
                        });
1463
1464
                        checkLoaded();
1465
                    });
1466
1467
                    return localRequire;
1468
                }
1469
1470
                mixin(localRequire, {
1471
                    isBrowser: isBrowser,
1472
1473
                    /**
1474
                     * Converts a module name + .extension into an URL path.
1475
                     * *Requires* the use of a module name. It does not support using
1476
                     * plain URLs like nameToUrl.
1477
                     */
1478
                    toUrl: function (moduleNamePlusExt) {
1479
                        var ext,
1480
                            index = moduleNamePlusExt.lastIndexOf('.'),
1481
                            segment = moduleNamePlusExt.split('/')[0],
1482
                            isRelative = segment === '.' || segment === '..';
1483
1484
                        //Have a file extension alias, and it is not the
1485
                        //dots from a relative path.
1486
                        if (index !== -1 && (!isRelative || index > 1)) {
1487
                            ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
1488
                            moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
1489
                        }
1490
1491
                        return context.nameToUrl(normalize(moduleNamePlusExt,
1492
                                                relMap && relMap.id, true), ext,  true);
0 ignored issues
show
Bug introduced by
The variable ext does not seem to be initialized in case index !== -1 && !isRelative || index > 1 on line 1486 is false. Are you sure the function nameToUrl handles undefined variables?
Loading history...
1493
                    },
1494
1495
                    defined: function (id) {
1496
                        return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
1497
                    },
1498
1499
                    specified: function (id) {
1500
                        id = makeModuleMap(id, relMap, false, true).id;
1501
                        return hasProp(defined, id) || hasProp(registry, id);
1502
                    }
1503
                });
1504
1505
                //Only allow undef on top level require calls
1506
                if (!relMap) {
1507
                    localRequire.undef = function (id) {
1508
                        //Bind any waiting define() calls to this context,
1509
                        //fix for #408
1510
                        takeGlobalQueue();
1511
1512
                        var map = makeModuleMap(id, relMap, true),
1513
                            mod = getOwn(registry, id);
1514
1515
                        mod.undefed = true;
1516
                        removeScript(id);
1517
1518
                        delete defined[id];
1519
                        delete urlFetched[map.url];
1520
                        delete undefEvents[id];
1521
1522
                        //Clean queued defines too. Go backwards
1523
                        //in array so that the splices do not
1524
                        //mess up the iteration.
1525
                        eachReverse(defQueue, function(args, i) {
1526
                            if (args[0] === id) {
1527
                                defQueue.splice(i, 1);
1528
                            }
1529
                        });
1530
                        delete context.defQueueMap[id];
1531
1532
                        if (mod) {
1533
                            //Hold on to listeners in case the
1534
                            //module will be attempted to be reloaded
1535
                            //using a different config.
1536
                            if (mod.events.defined) {
1537
                                undefEvents[id] = mod.events;
1538
                            }
1539
1540
                            cleanRegistry(id);
1541
                        }
1542
                    };
1543
                }
1544
1545
                return localRequire;
1546
            },
1547
1548
            /**
1549
             * Called to enable a module if it is still in the registry
1550
             * awaiting enablement. A second arg, parent, the parent module,
1551
             * is passed in for context, when this method is overridden by
1552
             * the optimizer. Not shown here to keep code compact.
1553
             */
1554
            enable: function (depMap) {
1555
                var mod = getOwn(registry, depMap.id);
1556
                if (mod) {
1557
                    getModule(depMap).enable();
1558
                }
1559
            },
1560
1561
            /**
1562
             * Internal method used by environment adapters to complete a load event.
1563
             * A load event could be a script load or just a load pass from a synchronous
1564
             * load call.
1565
             * @param {String} moduleName the name of the module to potentially complete.
1566
             */
1567
            completeLoad: function (moduleName) {
1568
                var found, args, mod,
1569
                    shim = getOwn(config.shim, moduleName) || {},
1570
                    shExports = shim.exports;
1571
1572
                takeGlobalQueue();
1573
1574
                while (defQueue.length) {
1575
                    args = defQueue.shift();
1576
                    if (args[0] === null) {
1577
                        args[0] = moduleName;
1578
                        //If already found an anonymous module and bound it
1579
                        //to this name, then this is some other anon module
1580
                        //waiting for its completeLoad to fire.
1581
                        if (found) {
1582
                            break;
1583
                        }
1584
                        found = true;
1585
                    } else if (args[0] === moduleName) {
1586
                        //Found matching define call for this script!
1587
                        found = true;
1588
                    }
1589
1590
                    callGetModule(args);
1591
                }
1592
                context.defQueueMap = {};
1593
1594
                //Do this after the cycle of callGetModule in case the result
1595
                //of those calls/init calls changes the registry.
1596
                mod = getOwn(registry, moduleName);
1597
1598
                if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
1599
                    if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
1600
                        if (hasPathFallback(moduleName)) {
1601
                            return;
1602
                        } else {
1603
                            return onError(makeError('nodefine',
1604
                                             'No define call for ' + moduleName,
1605
                                             null,
1606
                                             [moduleName]));
1607
                        }
1608
                    } else {
1609
                        //A script that does not call define(), so just simulate
1610
                        //the call for it.
1611
                        callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
1612
                    }
1613
                }
1614
1615
                checkLoaded();
0 ignored issues
show
Best Practice introduced by
There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.
Loading history...
1616
            },
1617
1618
            /**
1619
             * Converts a module name to a file path. Supports cases where
1620
             * moduleName may actually be just an URL.
1621
             * Note that it **does not** call normalize on the moduleName,
1622
             * it is assumed to have already been normalized. This is an
1623
             * internal API, not a public one. Use toUrl for the public API.
1624
             */
1625
            nameToUrl: function (moduleName, ext, skipExt) {
1626
                var paths, syms, i, parentModule, url,
1627
                    parentPath, bundleId,
1628
                    pkgMain = getOwn(config.pkgs, moduleName);
1629
1630
                if (pkgMain) {
1631
                    moduleName = pkgMain;
1632
                }
1633
1634
                bundleId = getOwn(bundlesMap, moduleName);
1635
1636
                if (bundleId) {
1637
                    return context.nameToUrl(bundleId, ext, skipExt);
1638
                }
1639
1640
                //If a colon is in the URL, it indicates a protocol is used and it is just
1641
                //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
1642
                //or ends with .js, then assume the user meant to use an url and not a module id.
1643
                //The slash is important for protocol-less URLs as well as full paths.
1644
                if (req.jsExtRegExp.test(moduleName)) {
1645
                    //Just a plain path, not module name lookup, so just return it.
1646
                    //Add extension if it is included. This is a bit wonky, only non-.js things pass
1647
                    //an extension, this method probably needs to be reworked.
1648
                    url = moduleName + (ext || '');
1649
                } else {
1650
                    //A module that needs to be converted to a path.
1651
                    paths = config.paths;
1652
1653
                    syms = moduleName.split('/');
1654
                    //For each module name segment, see if there is a path
1655
                    //registered for it. Start with most specific name
1656
                    //and work up from it.
1657
                    for (i = syms.length; i > 0; i -= 1) {
1658
                        parentModule = syms.slice(0, i).join('/');
1659
1660
                        parentPath = getOwn(paths, parentModule);
1661
                        if (parentPath) {
1662
                            //If an array, it means there are a few choices,
1663
                            //Choose the one that is desired
1664
                            if (isArray(parentPath)) {
1665
                                parentPath = parentPath[0];
1666
                            }
1667
                            syms.splice(0, i, parentPath);
1668
                            break;
1669
                        }
1670
                    }
1671
1672
                    //Join the path parts together, then figure out if baseUrl is needed.
1673
                    url = syms.join('/');
1674
                    url += (ext || (/^data\:|^blob\:|\?/.test(url) || skipExt ? '' : '.js'));
1675
                    url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
1676
                }
1677
1678
                return config.urlArgs && !/^blob\:/.test(url) ?
1679
                       url + config.urlArgs(moduleName, url) : url;
1680
            },
1681
1682
            //Delegates to req.load. Broken out as a separate function to
1683
            //allow overriding in the optimizer.
1684
            load: function (id, url) {
1685
                req.load(context, id, url);
1686
            },
1687
1688
            /**
1689
             * Executes a module callback function. Broken out as a separate function
1690
             * solely to allow the build system to sequence the files in the built
1691
             * layer in the right sequence.
1692
             *
1693
             * @private
1694
             */
1695
            execCb: function (name, callback, args, exports) {
1696
                return callback.apply(exports, args);
1697
            },
1698
1699
            /**
1700
             * callback for script loads, used to check status of loading.
1701
             *
1702
             * @param {Event} evt the event from the browser for the script
1703
             * that was loaded.
1704
             */
1705
            onScriptLoad: function (evt) {
1706
                //Using currentTarget instead of target for Firefox 2.0's sake. Not
1707
                //all old browsers will be supported, but this one was easy enough
1708
                //to support and still makes sense.
1709
                if (evt.type === 'load' ||
1710
                        (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
1711
                    //Reset interactive script so a script node is not held onto for
1712
                    //to long.
1713
                    interactiveScript = null;
1714
1715
                    //Pull out the name of the module and the context.
1716
                    var data = getScriptData(evt);
1717
                    context.completeLoad(data.id);
1718
                }
1719
            },
1720
1721
            /**
1722
             * Callback for script errors.
1723
             */
1724
            onScriptError: function (evt) {
1725
                var data = getScriptData(evt);
1726
                if (!hasPathFallback(data.id)) {
0 ignored issues
show
Complexity Best Practice introduced by
There is no return statement if !hasPathFallback(data.id) is false. Are you sure this is correct? If so, consider adding return; explicitly.

This check looks for functions where a return statement is found in some execution paths, but not in all.

Consider this little piece of code

function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

The function isBig will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return undefined.

This behaviour may not be what you had intended. In any case, you can add a return undefined to the other execution path to make the return value explicit.

Loading history...
1727
                    var parents = [];
1728
                    eachProp(registry, function(value, key) {
1729
                        if (key.indexOf('_@r') !== 0) {
1730
                            each(value.depMaps, function(depMap) {
1731
                                if (depMap.id === data.id) {
0 ignored issues
show
Complexity Best Practice introduced by
There is no return statement if depMap.id === data.id is false. Are you sure this is correct? If so, consider adding return; explicitly.

This check looks for functions where a return statement is found in some execution paths, but not in all.

Consider this little piece of code

function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

The function isBig will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return undefined.

This behaviour may not be what you had intended. In any case, you can add a return undefined to the other execution path to make the return value explicit.

Loading history...
1732
                                    parents.push(key);
1733
                                    return true;
1734
                                }
1735
                            });
1736
                        }
1737
                    });
1738
                    return onError(makeError('scripterror', 'Script error for "' + data.id +
1739
                                             (parents.length ?
1740
                                             '", needed by: ' + parents.join(', ') :
1741
                                             '"'), evt, [data.id]));
1742
                }
1743
            }
1744
        };
1745
1746
        context.require = context.makeRequire();
1747
        return context;
1748
    }
1749
1750
    /**
1751
     * Main entry point.
1752
     *
1753
     * If the only argument to require is a string, then the module that
1754
     * is represented by that string is fetched for the appropriate context.
1755
     *
1756
     * If the first argument is an array, then it will be treated as an array
1757
     * of dependency string names to fetch. An optional function callback can
1758
     * be specified to execute when all of those dependencies are available.
1759
     *
1760
     * Make a local req variable to help Caja compliance (it assumes things
1761
     * on a require that are not standardized), and to give a short
1762
     * name for minification/local scope use.
1763
     */
1764
    req = requirejs = function (deps, callback, errback, optional) {
1765
1766
        //Find the right context, use default
1767
        var context, config,
1768
            contextName = defContextName;
1769
1770
        // Determine if have config object in the call.
1771
        if (!isArray(deps) && typeof deps !== 'string') {
1772
            // deps is a config object
1773
            config = deps;
1774
            if (isArray(callback)) {
1775
                // Adjust args if there are dependencies
1776
                deps = callback;
1777
                callback = errback;
1778
                errback = optional;
1779
            } else {
1780
                deps = [];
1781
            }
1782
        }
1783
1784
        if (config && config.context) {
1785
            contextName = config.context;
1786
        }
1787
1788
        context = getOwn(contexts, contextName);
1789
        if (!context) {
1790
            context = contexts[contextName] = req.s.newContext(contextName);
1791
        }
1792
1793
        if (config) {
1794
            context.configure(config);
1795
        }
1796
1797
        return context.require(deps, callback, errback);
1798
    };
1799
1800
    /**
1801
     * Support require.config() to make it easier to cooperate with other
1802
     * AMD loaders on globally agreed names.
1803
     */
1804
    req.config = function (config) {
1805
        return req(config);
1806
    };
1807
1808
    /**
1809
     * Execute something after the current tick
1810
     * of the event loop. Override for other envs
1811
     * that have a better solution than setTimeout.
1812
     * @param  {Function} fn function to execute later.
1813
     */
1814
    req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
1815
        setTimeout(fn, 4);
1816
    } : function (fn) { fn(); };
1817
1818
    /**
1819
     * Export require as a global, but only if it does not already exist.
1820
     */
1821
    if (!require) {
1822
        require = req;
1823
    }
1824
1825
    req.version = version;
1826
1827
    //Used to filter out dependencies that are already paths.
1828
    req.jsExtRegExp = /^\/|:|\?|\.js$/;
1829
    req.isBrowser = isBrowser;
1830
    s = req.s = {
1831
        contexts: contexts,
1832
        newContext: newContext
1833
    };
1834
1835
    //Create default context.
1836
    req({});
1837
1838
    //Exports some context-sensitive methods on global require.
1839
    each([
1840
        'toUrl',
1841
        'undef',
1842
        'defined',
1843
        'specified'
1844
    ], function (prop) {
1845
        //Reference from contexts instead of early binding to default context,
1846
        //so that during builds, the latest instance of the default context
1847
        //with its config gets used.
1848
        req[prop] = function () {
1849
            var ctx = contexts[defContextName];
1850
            return ctx.require[prop].apply(ctx, arguments);
1851
        };
1852
    });
1853
1854
    if (isBrowser) {
1855
        head = s.head = document.getElementsByTagName('head')[0];
1856
        //If BASE tag is in play, using appendChild is a problem for IE6.
1857
        //When that browser dies, this can be removed. Details in this jQuery bug:
1858
        //http://dev.jquery.com/ticket/2709
1859
        baseElement = document.getElementsByTagName('base')[0];
1860
        if (baseElement) {
1861
            head = s.head = baseElement.parentNode;
1862
        }
1863
    }
1864
1865
    /**
1866
     * Any errors that require explicitly generates will be passed to this
1867
     * function. Intercept/override it if you want custom error handling.
1868
     * @param {Error} err the error object.
1869
     */
1870
    req.onError = defaultOnError;
1871
1872
    /**
1873
     * Creates the node for the load command. Only used in browser envs.
1874
     */
1875
    req.createNode = function (config, moduleName, url) {
0 ignored issues
show
Unused Code introduced by
The parameter url 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 moduleName 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...
1876
        var node = config.xhtml ?
1877
                document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
1878
                document.createElement('script');
1879
        node.type = config.scriptType || 'text/javascript';
1880
        node.charset = 'utf-8';
1881
        node.async = true;
1882
        return node;
1883
    };
1884
1885
    /**
1886
     * Does the request to load a module for the browser case.
1887
     * Make this a separate function to allow other environments
1888
     * to override it.
1889
     *
1890
     * @param {Object} context the require context to find state.
1891
     * @param {String} moduleName the name of the module.
1892
     * @param {Object} url the URL to the module.
1893
     */
1894
    req.load = function (context, moduleName, url) {
1895
        var config = (context && context.config) || {},
1896
            node;
1897
        if (isBrowser) {
1898
            //In the browser so use a script tag
1899
            node = req.createNode(config, moduleName, url);
1900
1901
            node.setAttribute('data-requirecontext', context.contextName);
1902
            node.setAttribute('data-requiremodule', moduleName);
1903
1904
            //Set up load listener. Test attachEvent first because IE9 has
1905
            //a subtle issue in its addEventListener and script onload firings
1906
            //that do not match the behavior of all other browsers with
1907
            //addEventListener support, which fire the onload event for a
1908
            //script right after the script execution. See:
1909
            //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
1910
            //UNFORTUNATELY Opera implements attachEvent but does not follow the script
1911
            //script execution mode.
1912
            if (node.attachEvent &&
1913
                    //Check if node.attachEvent is artificially added by custom script or
1914
                    //natively supported by browser
1915
                    //read https://github.com/requirejs/requirejs/issues/187
1916
                    //if we can NOT find [native code] then it must NOT natively supported.
1917
                    //in IE8, node.attachEvent does not have toString()
1918
                    //Note the test for "[native code" with no closing brace, see:
1919
                    //https://github.com/requirejs/requirejs/issues/273
1920
                    !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
1921
                    !isOpera) {
1922
                //Probably IE. IE (at least 6-8) do not fire
1923
                //script onload right after executing the script, so
1924
                //we cannot tie the anonymous define call to a name.
1925
                //However, IE reports the script as being in 'interactive'
1926
                //readyState at the time of the define call.
1927
                useInteractive = true;
1928
1929
                node.attachEvent('onreadystatechange', context.onScriptLoad);
1930
                //It would be great to add an error handler here to catch
1931
                //404s in IE9+. However, onreadystatechange will fire before
1932
                //the error handler, so that does not help. If addEventListener
1933
                //is used, then IE will fire error before load, but we cannot
1934
                //use that pathway given the connect.microsoft.com issue
1935
                //mentioned above about not doing the 'script execute,
1936
                //then fire the script load event listener before execute
1937
                //next script' that other browsers do.
1938
                //Best hope: IE10 fixes the issues,
1939
                //and then destroys all installs of IE 6-9.
1940
                //node.attachEvent('onerror', context.onScriptError);
1941
            } else {
1942
                node.addEventListener('load', context.onScriptLoad, false);
1943
                node.addEventListener('error', context.onScriptError, false);
1944
            }
1945
            node.src = url;
1946
1947
            //Calling onNodeCreated after all properties on the node have been
1948
            //set, but before it is placed in the DOM.
1949
            if (config.onNodeCreated) {
1950
                config.onNodeCreated(node, config, moduleName, url);
1951
            }
1952
1953
            //For some cache cases in IE 6-8, the script executes before the end
1954
            //of the appendChild execution, so to tie an anonymous define
1955
            //call to the module name (which is stored on the node), hold on
1956
            //to a reference to this node, but clear after the DOM insertion.
1957
            currentlyAddingScript = node;
1958
            if (baseElement) {
1959
                head.insertBefore(node, baseElement);
0 ignored issues
show
Bug introduced by
The variable head does not seem to be initialized in case isBrowser on line 1854 is false. Are you sure this can never be the case?
Loading history...
1960
            } else {
1961
                head.appendChild(node);
1962
            }
1963
            currentlyAddingScript = null;
1964
1965
            return node;
1966
        } else if (isWebWorker) {
0 ignored issues
show
Complexity Best Practice introduced by
There is no return statement if isWebWorker is false. Are you sure this is correct? If so, consider adding return; explicitly.

This check looks for functions where a return statement is found in some execution paths, but not in all.

Consider this little piece of code

function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

The function isBig will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return undefined.

This behaviour may not be what you had intended. In any case, you can add a return undefined to the other execution path to make the return value explicit.

Loading history...
1967
            try {
1968
                //In a web worker, use importScripts. This is not a very
1969
                //efficient use of importScripts, importScripts will block until
1970
                //its script is downloaded and evaluated. However, if web workers
1971
                //are in play, the expectation is that a build has been done so
1972
                //that only one script needs to be loaded anyway. This may need
1973
                //to be reevaluated if other use cases become common.
1974
1975
                // Post a task to the event loop to work around a bug in WebKit
1976
                // where the worker gets garbage-collected after calling
1977
                // importScripts(): https://webkit.org/b/153317
1978
                setTimeout(function() {}, 0);
1979
                importScripts(url);
1980
1981
                //Account for anonymous modules
1982
                context.completeLoad(moduleName);
0 ignored issues
show
Best Practice introduced by
There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.
Loading history...
1983
            } catch (e) {
1984
                context.onError(makeError('importscripts',
1985
                                'importScripts failed for ' +
1986
                                    moduleName + ' at ' + url,
1987
                                e,
1988
                                [moduleName]));
0 ignored issues
show
Best Practice introduced by
There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.
Loading history...
1989
            }
1990
        }
1991
    };
1992
1993
    function getInteractiveScript() {
1994
        if (interactiveScript && interactiveScript.readyState === 'interactive') {
1995
            return interactiveScript;
1996
        }
1997
1998
        eachReverse(scripts(), function (script) {
1999
            if (script.readyState === 'interactive') {
0 ignored issues
show
Complexity Best Practice introduced by
There is no return statement if script.readyState === "interactive" is false. Are you sure this is correct? If so, consider adding return; explicitly.

This check looks for functions where a return statement is found in some execution paths, but not in all.

Consider this little piece of code

function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

The function isBig will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return undefined.

This behaviour may not be what you had intended. In any case, you can add a return undefined to the other execution path to make the return value explicit.

Loading history...
2000
                return (interactiveScript = script);
2001
            }
2002
        });
2003
        return interactiveScript;
0 ignored issues
show
Bug introduced by
The variable interactiveScript does not seem to be initialized in case interactiveScript && int...State === "interactive" on line 1994 is false. Are you sure this can never be the case?
Loading history...
2004
    }
2005
2006
    //Look for a data-main script attribute, which could also adjust the baseUrl.
2007
    if (isBrowser && !cfg.skipDataMain) {
2008
        //Figure out baseUrl. Get it from the script tag with require.js in it.
2009
        eachReverse(scripts(), function (script) {
2010
            //Set the 'head' where we can append children by
2011
            //using the script's parent.
2012
            if (!head) {
2013
                head = script.parentNode;
2014
            }
2015
2016
            //Look for a data-main attribute to set main script for the page
2017
            //to load. If it is there, the path to data main becomes the
2018
            //baseUrl, if it is not already set.
2019
            dataMain = script.getAttribute('data-main');
2020
            if (dataMain) {
0 ignored issues
show
Complexity Best Practice introduced by
There is no return statement if dataMain is false. Are you sure this is correct? If so, consider adding return; explicitly.

This check looks for functions where a return statement is found in some execution paths, but not in all.

Consider this little piece of code

function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

The function isBig will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return undefined.

This behaviour may not be what you had intended. In any case, you can add a return undefined to the other execution path to make the return value explicit.

Loading history...
2021
                //Preserve dataMain in case it is a path (i.e. contains '?')
2022
                mainScript = dataMain;
2023
2024
                //Set final baseUrl if there is not already an explicit one,
2025
                //but only do so if the data-main value is not a loader plugin
2026
                //module ID.
2027
                if (!cfg.baseUrl && mainScript.indexOf('!') === -1) {
2028
                    //Pull off the directory of data-main for use as the
2029
                    //baseUrl.
2030
                    src = mainScript.split('/');
2031
                    mainScript = src.pop();
2032
                    subPath = src.length ? src.join('/')  + '/' : './';
2033
2034
                    cfg.baseUrl = subPath;
2035
                }
2036
2037
                //Strip off any trailing .js since mainScript is now
2038
                //like a module name.
2039
                mainScript = mainScript.replace(jsSuffixRegExp, '');
2040
2041
                //If mainScript is still a path, fall back to dataMain
2042
                if (req.jsExtRegExp.test(mainScript)) {
2043
                    mainScript = dataMain;
2044
                }
2045
2046
                //Put the data-main script in the files to load.
2047
                cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];
2048
2049
                return true;
2050
            }
2051
        });
2052
    }
2053
2054
    /**
2055
     * The function that handles definitions of modules. Differs from
2056
     * require() in that a string for the module should be the first argument,
2057
     * and the function to execute after dependencies are loaded should
2058
     * return a value to define the module corresponding to the first argument's
2059
     * name.
2060
     */
2061
    define = function (name, deps, callback) {
2062
        var node, context;
2063
2064
        //Allow for anonymous modules
2065
        if (typeof name !== 'string') {
2066
            //Adjust args appropriately
2067
            callback = deps;
2068
            deps = name;
2069
            name = null;
2070
        }
2071
2072
        //This module may not have dependencies
2073
        if (!isArray(deps)) {
2074
            callback = deps;
2075
            deps = null;
2076
        }
2077
2078
        //If no name, and callback is a function, then figure out if it a
2079
        //CommonJS thing with dependencies.
2080
        if (!deps && isFunction(callback)) {
2081
            deps = [];
2082
            //Remove comments from the callback string,
2083
            //look for require calls, and pull them into the dependencies,
2084
            //but only if there are function args.
2085
            if (callback.length) {
2086
                callback
2087
                    .toString()
2088
                    .replace(commentRegExp, commentReplace)
2089
                    .replace(cjsRequireRegExp, function (match, dep) {
2090
                        deps.push(dep);
2091
                    });
2092
2093
                //May be a CommonJS thing even without require calls, but still
2094
                //could use exports, and module. Avoid doing exports and module
2095
                //work though if it just needs require.
2096
                //REQUIRES the function to expect the CommonJS variables in the
2097
                //order listed below.
2098
                deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
2099
            }
2100
        }
2101
2102
        //If in IE 6-8 and hit an anonymous define() call, do the interactive
2103
        //work.
2104
        if (useInteractive) {
2105
            node = currentlyAddingScript || getInteractiveScript();
2106
            if (node) {
2107
                if (!name) {
2108
                    name = node.getAttribute('data-requiremodule');
2109
                }
2110
                context = contexts[node.getAttribute('data-requirecontext')];
2111
            }
2112
        }
2113
2114
        //Always save off evaluating the def call until the script onload handler.
2115
        //This allows multiple modules to be in a file without prematurely
2116
        //tracing dependencies, and allows for anonymous module support,
2117
        //where the module name is not known until the script onload event
2118
        //occurs. If no context, use the global queue, and get it processed
2119
        //in the onscript load callback.
2120
        if (context) {
2121
            context.defQueue.push([name, deps, callback]);
2122
            context.defQueueMap[name] = true;
2123
        } else {
2124
            globalDefQueue.push([name, deps, callback]);
2125
        }
2126
    };
2127
2128
    define.amd = {
2129
        jQuery: true
2130
    };
2131
2132
    /**
2133
     * Executes the text. Normally just uses eval, but can be modified
2134
     * to use a better, environment-specific call. Only used for transpiling
2135
     * loader plugins, not for plain JS modules.
2136
     * @param {String} text the text to execute/evaluate.
2137
     */
2138
    req.exec = function (text) {
2139
        /*jslint evil: true */
2140
        return eval(text);
0 ignored issues
show
Security Performance introduced by
Calls to eval are slow and potentially dangerous, especially on untrusted code. Please consider whether there is another way to achieve your goal.
Loading history...
2141
    };
2142
2143
    //Set up with config info.
2144
    req(cfg);
2145
}(this, (typeof setTimeout === 'undefined' ? undefined : setTimeout)));
2146