https://funadmin.com/static/require.js?v=1791141547

286
287        //Could match something like ')//comment', do not lose the prefix to comment.
288        function commentReplace(match, singlePrefix) {
289            return singlePrefix || '';
290        }
291
292        function isFunction(it) {
293            return ostring.call(it) === '[object Function]';
294        }
295
296        function isArray(it) {
297            return ostring.call(it) === '[object Array]';
298        }
299
300        /**
301         * Helper function for iterating over an array. If the func returns
302         * a true value, it will break out of the loop.
303         */
304        function each(ary, func) {
305            if (ary) {
306                var i;
307                for (i = 0; i < ary.length; i += 1) {
308                    if (ary[i] && func(ary[i], i, ary)) {
309                        break;
310                    }
311                }
312            }
313        }
314
315        /**
316         * Helper function for iterating over an array backwards. If the func
317         * returns a true value, it will break out of the loop.
318         */
319        function eachReverse(ary, func) {
320            if (ary) {
321                var i;
322                for (i = ary.length - 1; i > -1; i -= 1) {
323                    if (ary[i] && func(ary[i], i, ary)) {
324                        break;
325                    }
326                }
327            }
328        }
329
330        function hasProp(obj, prop) {
331            return hasOwn.call(obj, prop);
332        }
333
334        function getOwn(obj, prop) {
335            return hasProp(obj, prop) && obj[prop];
336        }
337
338        /**
339         * Cycles over properties in an object and calls a function for each
340         * property value. If the function returns a truthy value, then the
341         * iteration is stopped.
342         */
343        function eachProp(obj, func) {
344            var prop;
345            for (prop in obj) {
346                if (hasProp(obj, prop)) {
347                    if (func(obj[prop], prop)) {
348                        break;
349                    }
350                }
351            }
352        }
353
354        /**
355         * Simple function to mix in properties from source into target,
356         * but only if target does not already have a property of the same name.
357         */
358        function mixin(target, source, force, deepStringMixin) {
359            if (source) {
360                eachProp(source, function (value, prop) {
361                    if (force || !hasProp(target, prop)) {
362                        if (deepStringMixin && typeof value === 'object' && value &&
363                            !isArray(value) && !isFunction(value) &&
364                            !(value instanceof RegExp)) {
365
366                            if (!target[prop]) {
367                                target[prop] = {};
368                            }
369                            mixin(target[prop], value, force, deepStringMixin);
370                        } else {
371                            target[prop] = value;
372                        }
373                    }
374                });
375            }
376            return target;
377        }
378
379        //Similar to Function.prototype.bind, but the 'this' object is specified
380        //first, since it is easier to read/figure out what 'this' will be.
381        function bind(obj, fn) {
382            return function () {
383                return fn.apply(obj, arguments);
384            };
385        }
386
387        function scripts() {
388            return document.getElementsByTagName('script');
389        }
390
391        function defaultOnError(err) {
392            throw err;
393        }
394
395        //Allow getting a global that is expressed in
396        //dot notation, like 'a.b.c'.
397        function getGlobal(value) {
398            if (!value) {
399                return value;
400            }
401            var g = global;
402            each(value.split('.'), function (part) {
403                g = g[part];
404            });
405            return g;
406        }
407
408        /**
409         * Constructs an error with a pointer to an URL with more information.
410         * @param {String} id the error ID that maps to an ID on a web page.
411         * @param {String} message human readable error.
412         * @param {Error} [err] the original error, if there is one.
413         *
414         * @returns {Error}
415         */
416        function makeError(id, msg, err, requireModules) {
417            var e = new Error(msg + '\nhttps://requirejs.org/docs/errors.html#' + id);
418            e.requireType = id;
419            e.requireModules = requireModules;
420            if (err) {
421                e.originalError = err;
422            }
423            return e;
424        }
425
426        if (typeof define !== 'undefined') {
427            //If a define is already in play via another AMD loader,
428            //do not overwrite.
429            return;
430        }
431
432        if (typeof requirejs !== 'undefined') {
433            if (isFunction(requirejs)) {
434                //Do not overwrite an existing requirejs instance.
435                return;
436            }
437            cfg = requirejs;
438            requirejs = undefined;
439        }
440
441        //Allow for a require config object
442        if (typeof require !== 'undefined' && !isFunction(require)) {
443            //assume it is a config object.
444            cfg = require;
445            require = undefined;
446        }
447
448        function newContext(contextName) {
449            var inCheckLoaded, Module, context, handlers,
450                checkLoadedTimeoutId,
451                config = {
452                    //Defaults. Do not set a default for map
453                    //config to speed up normalize(), which
454                    //will run faster if there is no default.
455                    waitSeconds: 7,
456                    baseUrl: './',
457                    paths: {},
458                    bundles: {},
459                    pkgs: {},
460                    shim: {},
461                    config: {}
462                },
463                registry = {},
464                //registry of just enabled modules, to speed
465                //cycle breaking code when lots of modules
466                //are registered, but not activated.
467                enabledRegistry = {},
468                undefEvents = {},
469                defQueue = [],
470                defined = {},
471                urlFetched = {},
472                bundlesMap = {},
473                requireCounter = 1,
474                unnormalizedCounter = 1;
475
476            /**
477             * Trims the . and .. from an array of path segments.
478             * It will keep a leading path segment if a .. will become
479             * the first path segment, to help with module name lookups,
480             * which act like paths, but can be remapped. But the end result,
481             * all paths that use this function should look normalized.
482             * NOTE: this method MODIFIES the input array.
483             * @param {Array} ary the array of path segments.
484             */
485            function trimDots(ary) {
486                var i, part;
487                for (i = 0; i < ary.length; i++) {
488                    part = ary[i];
489                    if (part === '.') {
490                        ary.splice(i, 1);
491                        i -= 1;
492                    } else if (part === '..') {
493                        // If at the start, or previous value is still ..,
494                        // keep them so that when converted to a path it may
495                        // still work when converted to a path, even though
496                        // as an ID it is less than ideal. In larger point
497                        // releases, may be better to just kick out an error.
498                        if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
499                            continue;
500                        } else if (i > 0) {
501                            ary.splice(i - 1, 2);
502                            i -= 2;
503                        }
504                    }
505                }
506            }
507
508            /**
509             * Given a relative module name, like ./something, normalize it to
510             * a real name that can be mapped to a path.
511             * @param {String} name the relative name
512             * @param {String} baseName a real name that the name arg is relative
513             * to.
514             * @param {Boolean} applyMap apply the map config to the value. Should
515             * only be done if this normalization is for a dependency ID.
516             * @returns {String} normalized name
517             */
518            function normalize(name, baseName, applyMap) {
519                var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
520                    foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
521                    baseParts = (baseName && baseName.split('/')),
522                    map = config.map,
523                    starMap = map && map['*'];
524
525                //Adjust any relative paths.
526                if (name) {
527                    name = name.split('/');
528                    lastIndex = name.length - 1;
529
530                    // If wanting node ID compatibility, strip .js from end
531                    // of IDs. Have to do this here, and not in nameToUrl
532                    // because node allows either .js or non .js to map
533                    // to same file.
534                    if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
535                        name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
536                    }
537
538                    // Starts with a '.' so need the baseName
539                    if (name[0].charAt(0) === '.' && baseParts) {
540                        //Convert baseName to array, and lop off the last part,
541                        //so that . matches that 'directory' and not name of the baseName's
542                        //module. For instance, baseName of 'one/two/three', maps to
543                        //'one/two/three.js', but we want the directory, 'one/two' for
544                        //this normalization.
545                        normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
546                        name = normalizedBaseParts.concat(name);
547                    }
548
549                    trimDots(name);
550                    name = name.join('/');
551                }
552
553                //Apply map config if available.
554                if (applyMap && map && (baseParts || starMap)) {
555                    nameParts = name.split('/');
556
557                    outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
558                        nameSegment = nameParts.slice(0, i).join('/');
559
560                        if (baseParts) {
561                            //Find the longest baseName segment match in the config.
562                            //So, do joins on the biggest to smallest lengths of baseParts.
563                            for (j = baseParts.length; j > 0; j -= 1) {
564                                mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
565
566                                //baseName segment has config, find if it has one for
567                                //this name.
568                                if (mapValue) {
569                                    mapValue = getOwn(mapValue, nameSegment);
570                                    if (mapValue) {
571                                        //Match, update name to the new value.
572                                        foundMap = mapValue;
573                                        foundI = i;
574                                        break outerLoop;
575                                    }
576                                }
577                            }
578                        }
579
580                        //Check for a star map match, but just hold on to it,
581                        //if there is a shorter segment match later in a matching
582                        //config, then favor over this star map.
583                        if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
584                            foundStarMap = getOwn(starMap, nameSegment);
585                            starI = i;
586                        }
587                    }
588
589                    if (!foundMap && foundStarMap) {
590                        foundMap = foundStarMap;
591                        foundI = starI;
592                    }
593
594                    if (foundMap) {
595                        nameParts.splice(0, foundI, foundMap);
596                        name = nameParts.join('/');
597                    }
598                }
599
600                // If the name points to a package's name, use
601                // the package main instead.
602                pkgMain = getOwn(config.pkgs, name);
603
604                return pkgMain ? pkgMain : name;
605            }
606
607            function removeScript(name) {
608                if (isBrowser) {
609                    each(scripts(), function (scriptNode) {
610                        if (scriptNode.getAttribute('data-requiremodule') === name &&
611                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
612                            scriptNode.parentNode.removeChild(scriptNode);
613                            return true;
614                        }
615                    });
616                }
617            }
618
619            function hasPathFallback(id) {
620                var pathConfig = getOwn(config.paths, id);
621                if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
622                    //Pop off the first array value, since it failed, and
623                    //retry
624                    pathConfig.shift();
625                    context.require.undef(id);
626
627                    //Custom require that does not do map translation, since
628                    //ID is "absolute", already mapped/resolved.
629                    context.makeRequire(null, {
630                        skipMap: true
631                    })([id]);
632
633                    return true;
634                }
635            }
636
637            //Turns a plugin!resource to [plugin, resource]
638            //with the plugin being undefined if the name
639            //did not have a plugin prefix.
640            function splitPrefix(name) {
641                var prefix,
642                    index = name ? name.indexOf('!') : -1;
643                if (index > -1) {
644                    prefix = name.substring(0, index);
645                    name = name.substring(index + 1, name.length);
646                }
647                return [prefix, name];
648            }
649
650            /**
651             * Creates a module mapping that includes plugin prefix, module
652             * name, and path. If parentModuleMap is provided it will
653             * also normalize the name via require.normalize()
654             *
655             * @param {String} name the module name
656             * @param {String} [parentModuleMap] parent module map
657             * for the module name, used to resolve relative names.
658             * @param {Boolean} isNormalized: is the ID already normalized.
659             * This is true if this call is done for a define() module ID.
660             * @param {Boolean} applyMap: apply the map config to the ID.
661             * Should only be true if this map is for a dependency.
662             *
663             * @returns {Object}
664             */
665            function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
666                var url, pluginModule, suffix, nameParts,
667                    prefix = null,
668                    parentName = parentModuleMap ? parentModuleMap.name : null,
669                    originalName = name,
670                    isDefine = true,
671                    normalizedName = '';
672
673                //If no name, then it means it is a require call, generate an
674                //internal name.
675                if (!name) {
676                    isDefine = false;
677                    name = '_@r' + (requireCounter += 1);
678                }
679
680                nameParts = splitPrefix(name);
681                prefix = nameParts[0];
682                name = nameParts[1];
683
684                if (prefix) {
685                    prefix = normalize(prefix, parentName, applyMap);
686                    pluginModule = getOwn(defined, prefix);
687                }
688
689                //Account for relative paths if there is a base name.
690                if (name) {
691                    if (prefix) {
692                        if (isNormalized) {
693                            normalizedName = name;
694                        } else if (pluginModule && pluginModule.normalize) {
695                            //Plugin is loaded, use its normalize method.
696                            normalizedName = pluginModule.normalize(name, function (name) {
697                                return normalize(name, parentName, applyMap);
698                            });
699                        } else {
700                            // If nested plugin references, then do not try to
701                            // normalize, as it will not normalize correctly. This
702                            // places a restriction on resourceIds, and the longer
703                            // term solution is not to normalize until plugins are
704                            // loaded and all normalizations to allow for async
705                            // loading of a loader plugin. But for now, fixes the
706                            // common uses. Details in #1131
707                            normalizedName = name.indexOf('!') === -1 ?
708                                normalize(name, parentName, applyMap) :
709                                name;
710                        }
711                    } else {
712                        //A regular module.
713                        normalizedName = normalize(name, parentName, applyMap);
714
715                        //Normalized name may be a plugin ID due to map config
716                        //application in normalize. The map config values must
717                        //already be normalized, so do not need to redo that part.
718                        nameParts = splitPrefix(normalizedName);
719                        prefix = nameParts[0];
720                        normalizedName = nameParts[1];
721                        isNormalized = true;
722
723                        url = context.nameToUrl(normalizedName);
724                    }
725                }
726
727                //If the id is a plugin id that cannot be determined if it needs
728                //normalization, stamp it with a unique ID so two matching relative
729                //ids that may conflict can be separate.
730                suffix = prefix && !pluginModule && !isNormalized ?
731                    '_unnormalized' + (unnormalizedCounter += 1) :
732                    '';
733
734                return {
735                    prefix: prefix,
736                    name: normalizedName,
737                    parentMap: parentModuleMap,
738                    unnormalized: !!suffix,
739                    url: url,
740                    originalName: originalName,
741                    isDefine: isDefine,
742                    id: (prefix ?
743                        prefix + '!' + normalizedName :
744                        normalizedName) + suffix
745                };
746            }
747
748            function getModule(depMap) {
749                var id = depMap.id,
750                    mod = getOwn(registry, id);
751
752                if (!mod) {
753                    mod = registry[id] = new context.Module(depMap);
754                }
755
756                return mod;
757            }
758
759            function on(depMap, name, fn) {
760                var id = depMap.id,
761                    mod = getOwn(registry, id);
762
763                if (hasProp(defined, id) &&
764                    (!mod || mod.defineEmitComplete)) {
765                    if (name === 'defined') {
766                        fn(defined[id]);
767                    }
768                } else {
769                    mod = getModule(depMap);
770                    if (mod.error && name === 'error') {
771                        fn(mod.error);
772                    } else {
773                        mod.on(name, fn);
774                    }
775                }
776            }
777
778            function onError(err, errback) {
779                var ids = err.requireModules,
780                    notified = false;
781
782                if (errback) {
783                    errback(err);
784                } else {
785                    each(ids, function (id) {
786                        var mod = getOwn(registry, id);
787                        if (mod) {
788                            //Set error on module, so it skips timeout checks.
789                            mod.error = err;
790                            if (mod.events.error) {
791                                notified = true;
792                                mod.emit('error', err);
793                            }
794                        }
795                    });
796
797                    if (!notified) {
798                        req.onError(err);
799                    }
800                }
801            }
802
803            /**
804             * Internal method to transfer globalQueue items to this context's
805             * defQueue.
806             */
807            function takeGlobalQueue() {
808                //Push all the globalDefQueue items into the context's defQueue
809                if (globalDefQueue.length) {
810                    each(globalDefQueue, function(queueItem) {
811                        var id = queueItem[0];
812                        if (typeof id === 'string') {
813                            context.defQueueMap[id] = true;
814                        }
815                        defQueue.push(queueItem);
816                    });
817                    globalDefQueue = [];
818                }
819            }
820
821            handlers = {
822                'require': function (mod) {
823                    if (mod.require) {
824                        return mod.require;
825                    } else {
826                        return (mod.require = context.makeRequire(mod.map));
827                    }
828                },
829                'exports': function (mod) {
830                    mod.usingExports = true;
831                    if (mod.map.isDefine) {
832                        if (mod.exports) {
833                            return (defined[mod.map.id] = mod.exports);
834                        } else {
835                            return (mod.exports = defined[mod.map.id] = {});
836                        }
837                    }
838                },
839                'module': function (mod) {
840                    if (mod.module) {
841                        return mod.module;
842                    } else {
843                        return (mod.module = {
844                            id: mod.map.id,
845                            uri: mod.map.url,
846                            config: function () {
847                                return getOwn(config.config, mod.map.id) || {};
848                            },
849                            exports: mod.exports || (mod.exports = {})
850                        });
851                    }
852                }
853            };
854
855            function cleanRegistry(id) {
856                //Clean up machinery used for waiting modules.
857                delete registry[id];
858                delete enabledRegistry[id];
859            }
860
861            function breakCycle(mod, traced, processed) {
862                var id = mod.map.id;
863
864                if (mod.error) {
865                    mod.emit('error', mod.error);
866                } else {
867                    traced[id] = true;
868                    each(mod.depMaps, function (depMap, i) {
869                        var depId = depMap.id,
870                            dep = getOwn(registry, depId);
871
872                        //Only force things that have not completed
873                        //being defined, so still in the registry,
874                        //and only if it has not been matched up
875                        //in the module already.
876                        if (dep && !mod.depMatched[i] && !processed[depId]) {
877                            if (getOwn(traced, depId)) {
878                                mod.defineDep(i, defined[depId]);
879                                mod.check(); //pass false?
880                            } else {
881                                breakCycle(dep, traced, processed);
882                            }
883                        }
884                    });
885                    processed[id] = true;
886                }
887            }
888
889            function checkLoaded() {
890                var err, usingPathFallback,
891                    waitInterval = config.waitSeconds * 1000,
892                    //It is possible to disable the wait interval by using waitSeconds of 0.
893                    expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
894                    noLoads = [],
895                    reqCalls = [],
896                    stillLoading = false,
897                    needCycleCheck = true;
898
899                //Do not bother if this call was a result of a cycle break.
900                if (inCheckLoaded) {
901                    return;
902                }
903
904                inCheckLoaded = true;
905
906                //Figure out the state of all the modules.
907                eachProp(enabledRegistry, function (mod) {
908                    var map = mod.map,
909                        modId = map.id;
910
911                    //Skip things that are not enabled or in error state.
912                    if (!mod.enabled) {
913                        return;
914                    }
915
916                    if (!map.isDefine) {
917                        reqCalls.push(mod);
918                    }
919
920                    if (!mod.error) {
921                        //If the module should be executed, and it has not
922                        //been inited and time is up, remember it.
923                        if (!mod.inited && expired) {
924                            if (hasPathFallback(modId)) {
925                                usingPathFallback = true;
926                                stillLoading = true;
927                            } else {
928                                noLoads.push(modId);
929                                removeScript(modId);
930                            }
931                        } else if (!mod.inited && mod.fetched && map.isDefine) {
932                            stillLoading = true;
933                            if (!map.prefix) {
934                                //No reason to keep looking for unfinished
935                                //loading. If the only stillLoading is a
936                                //plugin resource though, keep going,
937                                //because it may be that a plugin resource
938                                //is waiting on a non-plugin cycle.
939                                return (needCycleCheck = false);
940                            }
941                        }
942                    }
943                });
944
945                if (expired && noLoads.length) {
946                    //If wait time expired, throw error of unloaded modules.
947                    err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
948                    err.contextName = context.contextName;
949                    return onError(err);
950                }
951
952                //Not expired, check for a cycle.
953                if (needCycleCheck) {
954                    each(reqCalls, function (mod) {
955                        breakCycle(mod, {}, {});
956                    });
957                }
958
959                //If still waiting on loads, and the waiting load is something
960                //other than a plugin resource, or there are still outstanding
961                //scripts, then just try back later.
962                if ((!expired || usingPathFallback) && stillLoading) {
963                    //Something is still waiting to load. Wait for it, but only
964                    //if a timeout is not already in effect.
965                    if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
966                        checkLoadedTimeoutId = setTimeout(function () {
967                            checkLoadedTimeoutId = 0;
968                            checkLoaded();
969                        }, 50);
970                    }
971                }
972
973                inCheckLoaded = false;
974            }
975
976            Module = function (map) {
977                this.events = getOwn(undefEvents, map.id) || {};
978                this.map = map;
979                this.shim = getOwn(config.shim, map.id);
980                this.depExports = [];
981                this.depMaps = [];
982                this.depMatched = [];
983                this.pluginMaps = {};
984                this.depCount = 0;
985
986                /* this.exports this.factory
987               this.depMaps = [],
988               this.enabled, this.fetched
989            */
990            };
991
992            Module.prototype = {
993                init: function (depMaps, factory, errback, options) {
994                    options = options || {};
995
996                    //Do not do more inits if already done. Can happen if there
997                    //are multiple define calls for the same module. That is not
998                    //a normal, common case, but it is also not unexpected.
999                    if (this.inited) {
1000                        return;
1001                    }
1002
1003                    this.factory = factory;
1004
1005                    if (errback) {
1006                        //Register for errors on this module.
1007                        this.on('error', errback);
1008                    } else if (this.events.error) {
1009                        //If no errback already, but there are error listeners
1010                        //on this module, set up an errback to pass to the deps.
1011                        errback = bind(this, function (err) {
1012                            this.emit('error', err);
1013                        });
1014                    }
1015
1016                    //Do a copy of the dependency array, so that
1017                    //source inputs are not modified. For example
1018                    //"shim" deps are passed in here directly, and
1019                    //doing a direct modification of the depMaps array
1020                    //would affect that config.
1021                    this.depMaps = depMaps && depMaps.slice(0);
1022
1023                    this.errback = errback;
1024
1025                    //Indicate this module has be initialized
1026                    this.inited = true;
1027
1028                    this.ignore = options.ignore;
1029
1030                    //Could have option to init this module in enabled mode,
1031                    //or could have been previously marked as enabled. However,
1032                    //the dependencies are not known until init is called. So
1033                    //if enabled previously, now trigger dependencies as enabled.
1034                    if (options.enabled || this.enabled) {
1035                        //Enable this module and dependencies.
1036                        //Will call this.check()
1037                        this.enable();
1038                    } else {
1039                        this.check();
1040                    }
1041                },
1042
1043                defineDep: function (i, depExports) {
1044                    //Because of cycles, defined callback for a given
1045                    //export can be called more than once.
1046                    if (!this.depMatched[i]) {
1047                        this.depMatched[i] = true;
1048                        this.depCount -= 1;
1049                        this.depExports[i] = depExports;
1050                    }
1051                },
1052
1053                fetch: function () {
1054                    if (this.fetched) {
1055                        return;
1056                    }
1057                    this.fetched = true;
1058
1059                    context.startTime = (new Date()).getTime();
1060
1061                    var map = this.map;
1062
1063                    //If the manager is for a plugin managed resource,
1064                    //ask the plugin to load it now.
1065                    if (this.shim) {
1066                        context.makeRequire(this.map, {
1067                            enableBuildCallback: true
1068                        })(this.shim.deps || [], bind(this, function () {
1069                            return map.prefix ? this.callPlugin() : this.load();
1070                        }));
1071                    } else {
1072                        //Regular dependency.
1073                        return map.prefix ? this.callPlugin() : this.load();
1074                    }
1075                },
1076
1077                load: function () {
1078                    var url = this.map.url;
1079
1080                    //Regular dependency.
1081                    if (!urlFetched[url]) {
1082                        urlFetched[url] = true;
1083                        context.load(this.map.id, url);
1084                    }
1085                },
1086
1087                /**
1088                 * Checks if the module is ready to define itself, and if so,
1089                 * define it.
1090                 */
1091                check: function () {
1092                    if (!this.enabled || this.enabling) {
1093                        return;
1094                    }
1095
1096                    var err, cjsModule,
1097                        id = this.map.id,
1098                        depExports = this.depExports,
1099                        exports = this.exports,
1100                        factory = this.factory;
1101
1102                    if (!this.inited) {
1103                        // Only fetch if not already in the defQueue.
1104                        if (!hasProp(context.defQueueMap, id)) {
1105                            this.fetch();
1106                        }
1107                    } else if (this.error) {
1108                        this.emit('error', this.error);
1109                    } else if (!this.defining) {
1110                        //The factory could trigger another require call
1111                        //that would result in checking this module to
1112                        //define itself again. If already in the process
1113                        //of doing that, skip this work.
1114                        this.defining = true;
1115
1116                        if (this.depCount < 1 && !this.defined) {
1117                            if (isFunction(factory)) {
1118                                //If there is an error listener, favor passing
1119                                //to that instead of throwing an error. However,
1120                                //only do it for define()'d  modules. require
1121                                //errbacks should not be called for failures in
1122                                //their callbacks (#699). However if a global
1123                                //onError is set, use that.
1124                                if ((this.events.error && this.map.isDefine) ||
1125                                    req.onError !== defaultOnError) {
1126                                    try {
1127                                        exports = context.execCb(id, factory, depExports, exports);
1128                                    } catch (e) {
1129                                        err = e;
1130                                    }
1131                                } else {
1132                                    exports = context.execCb(id, factory, depExports, exports);
1133                                }
1134
1135                                // Favor return value over exports. If node/cjs in play,
1136                                // then will not have a return value anyway. Favor
1137                                // module.exports assignment over exports object.
1138                                if (this.map.isDefine && exports === undefined) {
1139                                    cjsModule = this.module;
1140                                    if (cjsModule) {
1141                                        exports = cjsModule.exports;
1142                                    } else if (this.usingExports) {
1143                                        //exports already set the defined value.
1144                                        exports = this.exports;
1145                                    }
1146                                }
1147
1148                                if (err) {
1149                                    err.requireMap = this.map;
1150                                    err.requireModules = this.map.isDefine ? [this.map.id] : null;
1151                                    err.requireType = this.map.isDefine ? 'define' : 'require';
1152                                    return onError((this.error = err));
1153                                }
1154
1155                            } else {
1156                                //Just a literal value
1157                                exports = factory;
1158                            }
1159
1160                            this.exports = exports;
1161
1162                            if (this.map.isDefine && !this.ignore) {
1163                                defined[id] = exports;
1164
1165                                if (req.onResourceLoad) {
1166                                    var resLoadMaps = [];
1167                                    each(this.depMaps, function (depMap) {
1168                                        resLoadMaps.push(depMap.normalizedMap || depMap);
1169                                    });
1170                                    req.onResourceLoad(context, this.map, resLoadMaps);
1171                                }
1172                            }
1173
1174                            //Clean up
1175                            cleanRegistry(id);
1176
1177                            this.defined = true;
1178                        }
1179
1180                        //Finished the define stage. Allow calling check again
1181                        //to allow define notifications below in the case of a
1182                        //cycle.
1183                        this.defining = false;
1184
1185                        if (this.defined && !this.defineEmitted) {
1186                            this.defineEmitted = true;
1187                            this.emit('defined', this.exports);
1188                            this.defineEmitComplete = true;
1189                        }
1190
1191                    }
1192                },
1193
1194                callPlugin: function () {
1195                    var map = this.map,
1196                        id = map.id,
1197                        //Map already normalized the prefix.
1198                        pluginMap = makeModuleMap(map.prefix);
1199
1200                    //Mark this as a dependency for this plugin, so it
1201                    //can be traced for cycles.
1202                    this.depMaps.push(pluginMap);
1203
1204                    on(pluginMap, 'defined', bind(this, function (plugin) {
1205                        var load, normalizedMap, normalizedMod,
1206                            bundleId = getOwn(bundlesMap, this.map.id),
1207                            name = this.map.name,
1208                            parentName = this.map.parentMap ? this.map.parentMap.name : null,
1209                            localRequire = context.makeRequire(map.parentMap, {
1210                                enableBuildCallback: true
1211                            });
1212
1213                        //If current map is not normalized, wait for that
1214                        //normalized name to load instead of continuing.
1215                        if (this.map.unnormalized) {
1216                            //Normalize the ID if the plugin allows it.
1217                            if (plugin.normalize) {
1218                                name = plugin.normalize(name, function (name) {
1219                                    return normalize(name, parentName, true);
1220                                }) || '';
1221                            }
1222
1223                            //prefix and name should already be normalized, no need
1224                            //for applying map config again either.
1225                            normalizedMap = makeModuleMap(map.prefix + '!' + name,
1226                                this.map.parentMap,
1227                                true);
1228                            on(normalizedMap,
1229                                'defined', bind(this, function (value) {
1230                                    this.map.normalizedMap = normalizedMap;
1231                                    this.init([], function () { return value; }, null, {
1232                                        enabled: true,
1233                                        ignore: true
1234                                    });
1235                                }));
1236
1237                            normalizedMod = getOwn(registry, normalizedMap.id);
1238                            if (normalizedMod) {
1239                                //Mark this as a dependency for this plugin, so it
1240                                //can be traced for cycles.
1241                                this.depMaps.push(normalizedMap);
1242
1243                                if (this.events.error) {
1244                                    normalizedMod.on('error', bind(this, function (err) {
1245                                        this.emit('error', err);
1246                                    }));
1247                                }
1248                                normalizedMod.enable();
1249                            }
1250
1251                            return;
1252                        }
1253
1254                        //If a paths config, then just load that file instead to
1255                        //resolve the plugin, as it is built into that paths layer.
1256                        if (bundleId) {
1257                            this.map.url = context.nameToUrl(bundleId);
1258                            this.load();
1259                            return;
1260                        }
1261
1262                        load = bind(this, function (value) {
1263                            this.init([], function () { return value; }, null, {
1264                                enabled: true
1265                            });
1266                        });
1267
1268                        load.error = bind(this, function (err) {
1269                            this.inited = true;
1270                            this.error = err;
1271                            err.requireModules = [id];
1272
1273                            //Remove temp unnormalized modules for this module,
1274                            //since they will never be resolved otherwise now.
1275                            eachProp(registry, function (mod) {
1276                                if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
1277                                    cleanRegistry(mod.map.id);
1278                                }
1279                            });
1280
1281                            onError(err);
1282                        });
1283
1284                        //Allow plugins to load other code without having to know the
1285                        //context or how to 'complete' the load.
1286                        load.fromText = bind(this, function (text, textAlt) {
1287                            /*jslint evil: true */
1288                            var moduleName = map.name,
1289                                moduleMap = makeModuleMap(moduleName),
1290                                hasInteractive = useInteractive;
1291
1292                            //As of 2.1.0, support just passing the text, to reinforce
1293                            //fromText only being called once per resource. Still
1294                            //support old style of passing moduleName but discard
1295                            //that moduleName in favor of the internal ref.
1296                            if (textAlt) {
1297                                text = textAlt;
1298                            }
1299
1300                            //Turn off interactive script matching for IE for any define
1301                            //calls in the text, then turn it back on at the end.
1302                            if (hasInteractive) {
1303                                useInteractive = false;
1304                            }
1305
1306                            //Prime the system by creating a module instance for
1307                            //it.
1308                            getModule(moduleMap);
1309
1310                            //Transfer any config to this other module.
1311                            if (hasProp(config.config, id)) {
1312                                config.config[moduleName] = config.config[id];
1313                            }
1314
1315                            try {
1316                                req.exec(text);
1317                            } catch (e) {
1318                                return onError(makeError('fromtexteval',
1319                                    'fromText eval for ' + id +
1320                                    ' failed: ' + e,
1321                                    e,
1322                                    [id]));
1323                            }
1324
1325                            if (hasInteractive) {
1326                                useInteractive = true;
1327                            }
1328
1329                            //Mark this as a dependency for the plugin
1330                            //resource
1331                            this.depMaps.push(moduleMap);
1332
1333                            //Support anonymous modules.
1334                            context.completeLoad(moduleName);
1335
1336                            //Bind the value of that module to the value for this
1337                            //resource ID.
1338                            localRequire([moduleName], load);
1339                        });
1340
1341                        //Use parentName here since the plugin's name is not reliable,
1342                        //could be some weird string with no path that actually wants to
1343                        //reference the parentName's path.
1344                        plugin.load(map.name, localRequire, load, config);
1345                    }));
1346
1347                    context.enable(pluginMap, this);
1348                    this.pluginMaps[pluginMap.id] = pluginMap;
1349                },
1350
1351                enable: function () {
1352                    enabledRegistry[this.map.id] = this;
1353                    this.enabled = true;
1354
1355                    //Set flag mentioning that the module is enabling,
1356                    //so that immediate calls to the defined callbacks
1357                    //for dependencies do not trigger inadvertent load
1358                    //with the depCount still being zero.
1359                    this.enabling = true;
1360
1361                    //Enable each dependency
1362                    each(this.depMaps, bind(this, function (depMap, i) {
1363                        var id, mod, handler;
1364
1365                        if (typeof depMap === 'string') {
1366                            //Dependency needs to be converted to a depMap
1367                            //and wired up to this module.
1368                            depMap = makeModuleMap(depMap,
1369                                (this.map.isDefine ? this.map : this.map.parentMap),
1370                                false,
1371                                !this.skipMap);
1372                            this.depMaps[i] = depMap;
1373
1374                            handler = getOwn(handlers, depMap.id);
1375
1376                            if (handler) {
1377                                this.depExports[i] = handler(this);
1378                                return;
1379                            }
1380
1381                            this.depCount += 1;
1382
1383                            on(depMap, 'defined', bind(this, function (depExports) {
1384                                if (this.undefed) {
1385                                    return;
1386                                }
1387                                this.defineDep(i, depExports);
1388                                this.check();
1389                            }));
1390
1391                            if (this.errback) {
1392                                on(depMap, 'error', bind(this, this.errback));
1393                            } else if (this.events.error) {
1394                                // No direct errback on this module, but something
1395                                // else is listening for errors, so be sure to
1396                                // propagate the error correctly.
1397                                on(depMap, 'error', bind(this, function(err) {
1398                                    this.emit('error', err);
1399                                }));
1400                            }
1401                        }
1402
1403                        id = depMap.id;
1404                        mod = registry[id];
1405
1406                        //Skip special modules like 'require', 'exports', 'module'
1407                        //Also, don't call enable if it is already enabled,
1408                        //important in circular dependency cases.
1409                        if (!hasProp(handlers, id) && mod && !mod.enabled) {
1410                            context.enable(depMap, this);
1411                        }
1412                    }));
1413
1414                    //Enable each plugin that is used in
1415                    //a dependency
1416                    eachProp(this.pluginMaps, bind(this, function (pluginMap) {
1417                        var mod = getOwn(registry, pluginMap.id);
1418                        if (mod && !mod.enabled) {
1419                            context.enable(pluginMap, this);
1420                        }
1421                    }));
1422
1423                    this.enabling = false;
1424
1425                    this.check();
1426                },
1427
1428                on: function (name, cb) {
1429                    var cbs = this.events[name];
1430                    if (!cbs) {
1431                        cbs = this.events[name] = [];
1432                    }
1433                    cbs.push(cb);
1434                },
1435
1436                emit: function (name, evt) {
1437                    each(this.events[name], function (cb) {
1438                        cb(evt);
1439                    });
1440                    if (name === 'error') {
1441                        //Now that the error handler was triggered, remove
1442                        //the listeners, since this broken Module instance
1443                        //can stay around for a while in the registry.
1444                        delete this.events[name];
1445                    }
1446                }
1447            };
1448
1449            function callGetModule(args) {
1450                //Skip modules already defined.
1451                if (!hasProp(defined, args[0])) {
1452                    getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
1453                }
1454            }
1455
1456            function removeListener(node, func, name, ieName) {
1457                //Favor detachEvent because of IE9
1458                //issue, see attachEvent/addEventListener comment elsewhere
1459                //in this file.
1460                if (node.detachEvent && !isOpera) {
1461                    //Probably IE. If not it will throw an error, which will be
1462                    //useful to know.
1463                    if (ieName) {
1464                        node.detachEvent(ieName, func);
1465                    }
1466                } else {
1467                    node.removeEventListener(name, func, false);
1468                }
1469            }
1470
1471            /**
1472             * Given an event from a script node, get the requirejs info from it,
1473             * and then removes the event listeners on the node.
1474             * @param {Event} evt
1475             * @returns {Object}
1476             */
1477            function getScriptData(evt) {
1478                //Using currentTarget instead of target for Firefox 2.0's sake. Not
1479                //all old browsers will be supported, but this one was easy enough
1480                //to support and still makes sense.
1481                var node = evt.currentTarget || evt.srcElement;
1482
1483                //Remove the listeners once here.
1484                removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
1485                removeListener(node, context.onScriptError, 'error');
1486
1487                return {
1488                    node: node,
1489                    id: node && node.getAttribute('data-requiremodule')
1490                };
1491            }
1492
1493            function intakeDefines() {
1494                var args;
1495
1496                //Any defined modules in the global queue, intake them now.
1497                takeGlobalQueue();
1498
1499                //Make sure any remaining defQueue items get properly processed.
1500                while (defQueue.length) {
1501                    args = defQueue.shift();
1502                    if (args[0] === null) {
1503                        return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' +
1504                            args[args.length - 1]));
1505                    } else {
1506                        //args are id, deps, factory. Should be normalized by the
1507                        //define() function.
1508                        callGetModule(args);
1509                    }
1510                }
1511                context.defQueueMap = {};
1512            }
1513
1514            context = {
1515                config: config,
1516                contextName: contextName,
1517                registry: registry,
1518                defined: defined,
1519                urlFetched: urlFetched,
1520                defQueue: defQueue,
1521                defQueueMap: {},
1522                Module: Module,
1523                makeModuleMap: makeModuleMap,
1524                nextTick: req.nextTick,
1525                onError: onError,
1526
1527                /**
1528                 * Set a configuration for the context.
1529                 * @param {Object} cfg config object to integrate.
1530                 */
1531                configure: function (cfg) {
1532                    //Make sure the baseUrl ends in a slash.
1533                    if (cfg.baseUrl) {
1534                        if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
1535                            cfg.baseUrl += '/';
1536                        }
1537                    }
1538
1539                    // Convert old style urlArgs string to a function.
1540                    if (typeof cfg.urlArgs === 'string') {
1541                        var urlArgs = cfg.urlArgs;
1542                        cfg.urlArgs = function(id, url) {
1543                            return (url.indexOf('?') === -1 ? '?' : '&') + urlArgs;
1544                        };
1545                    }
1546
1547                    //Save off the paths since they require special processing,
1548                    //they are additive.
1549                    var shim = config.shim,
1550                        objs = {
1551                            paths: true,
1552                            bundles: true,
1553                            config: true,
1554                            map: true
1555                        };
1556
1557                    eachProp(cfg, function (value, prop) {
1558                        if (objs[prop]) {
1559                            if (!config[prop]) {
1560                                config[prop] = {};
1561                            }
1562                            mixin(config[prop], value, true, true);
1563                        } else {
1564                            config[prop] = value;
1565                        }
1566                    });
1567
1568                    //Reverse map the bundles
1569                    if (cfg.bundles) {
1570                        eachProp(cfg.bundles, function (value, prop) {
1571                            each(value, function (v) {
1572                                if (v !== prop) {
1573                                    bundlesMap[v] = prop;
1574                                }
1575                            });
1576                        });
1577                    }
1578
1579                    //Merge shim
1580                    if (cfg.shim) {
1581                        eachProp(cfg.shim, function (value, id) {
1582                            //Normalize the structure
1583                            if (isArray(value)) {
1584                                value = {
1585                                    deps: value
1586                                };
1587                            }
1588                            if ((value.exports || value.init) && !value.exportsFn) {
1589                                value.exportsFn = context.makeShimExports(value);
1590                            }
1591                            shim[id] = value;
1592                        });
1593                        config.shim = shim;
1594                    }
1595
1596                    //Adjust packages if necessary.
1597                    if (cfg.packages) {
1598                        each(cfg.packages, function (pkgObj) {
1599                            var location, name;
1600
1601                            pkgObj = typeof pkgObj === 'string' ? {name: pkgObj} : pkgObj;
1602
1603                            name = pkgObj.name;
1604                            location = pkgObj.location;
1605                            if (location) {
1606                                config.paths[name] = pkgObj.location;
1607                            }
1608
1609                            //Save pointer to main module ID for pkg name.
1610                            //Remove leading dot in main, so main paths are normalized,
1611                            //and remove any trailing .js, since different package
1612                            //envs have different conventions: some use a module name,
1613                            //some use a file name.
1614                            config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
1615                                .replace(currDirRegExp, '')
1616                                .replace(jsSuffixRegExp, '');
1617                        });
1618                    }
1619
1620                    //If there are any "waiting to execute" modules in the registry,
1621                    //update the maps for them, since their info, like URLs to load,
1622                    //may have changed.
1623                    eachProp(registry, function (mod, id) {
1624                        //If module already has init called, since it is too
1625                        //late to modify them, and ignore unnormalized ones
1626                        //since they are transient.
1627                        if (!mod.inited && !mod.map.unnormalized) {
1628                            mod.map = makeModuleMap(id, null, true);
1629                        }
1630                    });
1631
1632                    //If a deps array or a config callback is specified, then call
1633                    //require with those args. This is useful when require is defined as a
1634                    //config object before require.js is loaded.
1635                    if (cfg.deps || cfg.callback) {
1636                        context.require(cfg.deps || [], cfg.callback);
1637                    }
1638                },
1639
1640                makeShimExports: function (value) {
1641                    function fn() {
1642                        var ret;
1643                        if (value.init) {
1644                            ret = value.init.apply(global, arguments);
1645                        }
1646                        return ret || (value.exports && getGlobal(value.exports));
1647                    }
1648                    return fn;
1649                },
1650
1651                makeRequire: function (relMap, options) {
1652                    options = options || {};
1653
1654                    function localRequire(deps, callback, errback) {
1655                        var id, map, requireMod;
1656
1657                        if (options.enableBuildCallback && callback && isFunction(callback)) {
1658                            callback.__requireJsBuild = true;
1659                        }
1660
1661                        if (typeof deps === 'string') {
1662                            if (isFunction(callback)) {
1663                                //Invalid call
1664                                return onError(makeError('requireargs', 'Invalid require call'), errback);
1665                            }
1666
1667                            //If require|exports|module are requested, get the
1668                            //value for them from the special handlers. Caveat:
1669                            //this only works while module is being defined.
1670                            if (relMap && hasProp(handlers, deps)) {
1671                                return handlers[deps](registry[relMap.id]);
1672                            }
1673
1674                            //Synchronous access to one module. If require.get is
1675                            //available (as in the Node adapter), prefer that.
1676                            if (req.get) {
1677                                return req.get(context, deps, relMap, localRequire);
1678                            }
1679
1680                            //Normalize module name, if it contains . or ..
1681                            map = makeModuleMap(deps, relMap, false, true);
1682                            id = map.id;
1683
1684                            if (!hasProp(defined, id)) {
1685                                return onError(makeError('notloaded', 'Module name "' +
1686                                    id +
1687                                    '" has not been loaded yet for context: ' +
1688                                    contextName +
1689                                    (relMap ? '' : '. Use require([])')));
1690                            }
1691                            return defined[id];
1692                        }
1693
1694                        //Grab defines waiting in the global queue.
1695                        intakeDefines();
1696
1697                        //Mark all the dependencies as needing to be loaded.
1698                        context.nextTick(function () {
1699                            //Some defines could have been added since the
1700                            //require call, collect them.
1701                            intakeDefines();
1702
1703                            requireMod = getModule(makeModuleMap(null, relMap));
1704
1705                            //Store if map config should be applied to this require
1706                            //call for dependencies.
1707                            requireMod.skipMap = options.skipMap;
1708
1709                            requireMod.init(deps, callback, errback, {
1710                                enabled: true
1711                            });
1712
1713                            checkLoaded();
1714                        });
1715
1716                        return localRequire;
1717                    }
1718
1719                    mixin(localRequire, {
1720                        isBrowser: isBrowser,
1721
1722                        /**
1723                         * Converts a module name + .extension into an URL path.
1724                         * *Requires* the use of a module name. It does not support using
1725                         * plain URLs like nameToUrl.
1726                         */
1727                        toUrl: function (moduleNamePlusExt) {
1728                            var ext,
1729                                index = moduleNamePlusExt.lastIndexOf('.'),
1730                                segment = moduleNamePlusExt.split('/')[0],
1731                                isRelative = segment === '.' || segment === '..';
1732
1733                            //Have a file extension alias, and it is not the
1734                            //dots from a relative path.
1735                            if (index !== -1 && (!isRelative || index > 1)) {
1736                                ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
1737                                moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
1738                            }
1739
1740                            return context.nameToUrl(normalize(moduleNamePlusExt,
1741                                relMap && relMap.id, true), ext,  true);
1742                        },
1743
1744                        defined: function (id) {
1745                            return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
1746                        },
1747
1748                        specified: function (id) {
1749                            id = makeModuleMap(id, relMap, false, true).id;
1750                            return hasProp(defined, id) || hasProp(registry, id);
1751                        }
1752                    });
1753
1754                    //Only allow undef on top level require calls
1755                    if (!relMap) {
1756                        localRequire.undef = function (id) {
1757                            //Bind any waiting define() calls to this context,
1758                            //fix for #408
1759                            takeGlobalQueue();
1760
1761                            var map = makeModuleMap(id, relMap, true),
1762                                mod = getOwn(registry, id);
1763
1764                            mod.undefed = true;
1765                            removeScript(id);
1766
1767                            delete defined[id];
1768                            delete urlFetched[map.url];
1769                            delete undefEvents[id];
1770
1771                            //Clean queued defines too. Go backwards
1772                            //in array so that the splices do not
1773                            //mess up the iteration.
1774                            eachReverse(defQueue, function(args, i) {
1775                                if (args[0] === id) {
1776                                    defQueue.splice(i, 1);
1777                                }
1778                            });
1779                            delete context.defQueueMap[id];
1780
1781                            if (mod) {
1782                                //Hold on to listeners in case the
1783                                //module will be attempted to be reloaded
1784                                //using a different config.
1785                                if (mod.events.defined) {
1786                                    undefEvents[id] = mod.events;
1787                                }
1788
1789                                cleanRegistry(id);
1790                            }
1791                        };
1792                    }
1793
1794                    return localRequire;
1795                },
1796
1797                /**
1798                 * Called to enable a module if it is still in the registry
1799                 * awaiting enablement. A second arg, parent, the parent module,
1800                 * is passed in for context, when this method is overridden by
1801                 * the optimizer. Not shown here to keep code compact.
1802                 */
1803                enable: function (depMap) {
1804                    var mod = getOwn(registry, depMap.id);
1805                    if (mod) {
1806                        getModule(depMap).enable();
1807                    }
1808                },
1809
1810                /**
1811                 * Internal method used by environment adapters to complete a load event.
1812                 * A load event could be a script load or just a load pass from a synchronous
1813                 * load call.
1814                 * @param {String} moduleName the name of the module to potentially complete.
1815                 */
1816                completeLoad: function (moduleName) {
1817                    var found, args, mod,
1818                        shim = getOwn(config.shim, moduleName) || {},
1819                        shExports = shim.exports;
1820
1821                    takeGlobalQueue();
1822
1823                    while (defQueue.length) {
1824                        args = defQueue.shift();
1825                        if (args[0] === null) {
1826                            args[0] = moduleName;
1827                            //If already found an anonymous module and bound it
1828                            //to this name, then this is some other anon module
1829                            //waiting for its completeLoad to fire.
1830                            if (found) {
1831                                break;
1832                            }
1833                            found = true;
1834                        } else if (args[0] === moduleName) {
1835                            //Found matching define call for this script!
1836                            found = true;
1837                        }
1838
1839                        callGetModule(args);
1840                    }
1841                    context.defQueueMap = {};
1842
1843                    //Do this after the cycle of callGetModule in case the result
1844                    //of those calls/init calls changes the registry.
1845                    mod = getOwn(registry, moduleName);
1846
1847                    if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
1848                        if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
1849                            if (hasPathFallback(moduleName)) {
1850                                return;
1851                            } else {
1852                                return onError(makeError('nodefine',
1853                                    'No define call for ' + moduleName,
1854                                    null,
1855                                    [moduleName]));
1856                            }
1857                        } else {
1858                            //A script that does not call define(), so just simulate
1859                            //the call for it.
1860                            callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
1861                        }
1862                    }
1863
1864                    checkLoaded();
1865                },
1866
1867                /**
1868                 * Converts a module name to a file path. Supports cases where
1869                 * moduleName may actually be just an URL.
1870                 * Note that it **does not** call normalize on the moduleName,
1871                 * it is assumed to have already been normalized. This is an
1872                 * internal API, not a public one. Use toUrl for the public API.
1873                 */
1874                nameToUrl: function (moduleName, ext, skipExt) {
1875                    var paths, syms, i, parentModule, url,
1876                        parentPath, bundleId,
1877                        pkgMain = getOwn(config.pkgs, moduleName);
1878
1879                    if (pkgMain) {
1880                        moduleName = pkgMain;
1881                    }
1882
1883                    bundleId = getOwn(bundlesMap, moduleName);
1884
1885                    if (bundleId) {
1886                        return context.nameToUrl(bundleId, ext, skipExt);
1887                    }
1888
1889                    //If a colon is in the URL, it indicates a protocol is used and it is just
1890                    //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
1891                    //or ends with .js, then assume the user meant to use an url and not a module id.
1892                    //The slash is important for protocol-less URLs as well as full paths.
1893                    if (req.jsExtRegExp.test(moduleName)) {
1894                        //Just a plain path, not module name lookup, so just return it.
1895                        //Add extension if it is included. This is a bit wonky, only non-.js things pass
1896                        //an extension, this method probably needs to be reworked.
1897                        url = moduleName + (ext || '');
1898                    } else {
1899                        //A module that needs to be converted to a path.
1900                        paths = config.paths;
1901
1902                        syms = moduleName.split('/');
1903                        //For each module name segment, see if there is a path
1904                        //registered for it. Start with most specific name
1905                        //and work up from it.
1906                        for (i = syms.length; i > 0; i -= 1) {
1907                            parentModule = syms.slice(0, i).join('/');
1908
1909                            parentPath = getOwn(paths, parentModule);
1910                            if (parentPath) {
1911                                //If an array, it means there are a few choices,
1912                                //Choose the one that is desired
1913                                if (isArray(parentPath)) {
1914                                    parentPath = parentPath[0];
1915                                }
1916                                syms.splice(0, i, parentPath);
1917                                break;
1918                            }
1919                        }
1920
1921                        //Join the path parts together, then figure out if baseUrl is needed.
1922                        url = syms.join('/');
1923                        url += (ext || (/^data\:|^blob\:|\?/.test(url) || skipExt ? '' : '.js'));
1924                        url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
1925                    }
1926
1927                    return config.urlArgs && !/^blob\:/.test(url) ?
1928                        url + config.urlArgs(moduleName, url) : url;
1929                },
1930
1931                //Delegates to req.load. Broken out as a separate function to
1932                //allow overriding in the optimizer.
1933                load: function (id, url) {
1934                    req.load(context, id, url);
1935                },
1936
1937                /**
1938                 * Executes a module callback function. Broken out as a separate function
1939                 * solely to allow the build system to sequence the files in the built
1940                 * layer in the right sequence.
1941                 *
1942                 * @private
1943                 */
1944                execCb: function (name, callback, args, exports) {
1945                    return callback.apply(exports, args);
1946                },
1947
1948                /**
1949                 * callback for script loads, used to check status of loading.
1950                 *
1951                 * @param {Event} evt the event from the browser for the script
1952                 * that was loaded.
1953                 */
1954                onScriptLoad: function (evt) {
1955                    //Using currentTarget instead of target for Firefox 2.0's sake. Not
1956                    //all old browsers will be supported, but this one was easy enough
1957                    //to support and still makes sense.
1958                    if (evt.type === 'load' ||
1959                        (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
1960                        //Reset interactive script so a script node is not held onto for
1961                        //to long.
1962                        interactiveScript = null;
1963
1964                        //Pull out the name of the module and the context.
1965                        var data = getScriptData(evt);
1966                        context.completeLoad(data.id);
1967                    }
1968                },
1969
1970                /**
1971                 * Callback for script errors.
1972                 */
1973                onScriptError: function (evt) {
1974                    var data = getScriptData(evt);
1975                    if (!hasPathFallback(data.id)) {
1976                        var parents = [];
1977                        eachProp(registry, function(value, key) {
1978                            if (key.indexOf('_@r') !== 0) {
1979                                each(value.depMaps, function(depMap) {
1980                                    if (depMap.id === data.id) {
1981                                        parents.push(key);
1982                                        return true;
1983                                    }
1984                                });
1985                            }
1986                        });
1987                        return onError(makeError('scripterror', 'Script error for "' + data.id +
1988                            (parents.length ?
1989                                '", needed by: ' + parents.join(', ') :
1990                                '"'), evt, [data.id]));
1991                    }
1992                }
1993            };
1994
1995            context.require = context.makeRequire();
1996            return context;
1997        }
1998
1999        /**
2000         * Main entry point.
2001         *
2002         * If the only argument to require is a string, then the module that
2003         * is represented by that string is fetched for the appropriate context.
2004         *
2005         * If the first argument is an array, then it will be treated as an array
2006         * of dependency string names to fetch. An optional function callback can
2007         * be specified to execute when all of those dependencies are available.
2008         *
2009         * Make a local req variable to help Caja compliance (it assumes things
2010         * on a require that are not standardized), and to give a short
2011         * name for minification/local scope use.
2012         */
2013        req = requirejs = function (deps, callback, errback, optional) {
2014
2015            //Find the right context, use default
2016            var context, config,
2017                contextName = defContextName;
2018
2019            // Determine if have config object in the call.
2020            if (!isArray(deps) && typeof deps !== 'string') {
2021                // deps is a config object
2022                config = deps;
2023                if (isArray(callback)) {
2024                    // Adjust args if there are dependencies
2025                    deps = callback;
2026                    callback = errback;
2027                    errback = optional;
2028                } else {
2029                    deps = [];
2030                }
2031            }
2032
2033            if (config && config.context) {
2034                contextName = config.context;
2035            }
2036
2037            context = getOwn(contexts, contextName);
2038            if (!context) {
2039                context = contexts[contextName] = req.s.newContext(contextName);
2040            }
2041
2042            if (config) {
2043                context.configure(config);
2044            }
2045
2046            return context.require(deps, callback, errback);
2047        };
2048
2049        /**
2050         * Support require.config() to make it easier to cooperate with other
2051         * AMD loaders on globally agreed names.
2052         */
2053        req.config = function (config) {
2054            return req(config);
2055        };
2056
2057        /**
2058         * Execute something after the current tick
2059         * of the event loop. Override for other envs
2060         * that have a better solution than setTimeout.
2061         * @param  {Function} fn function to execute later.
2062         */
2063        req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
2064            setTimeout(fn, 4);
2065        } : function (fn) { fn(); };
2066
2067        /**
2068         * Export require as a global, but only if it does not already exist.
2069         */
2070        if (!require) {
2071            require = req;
2072        }
2073
2074        req.version = version;
2075
2076        //Used to filter out dependencies that are already paths.
2077        req.jsExtRegExp = /^\/|:|\?|\.js$/;
2078        req.isBrowser = isBrowser;
2079        s = req.s = {
2080            contexts: contexts,
2081            newContext: newContext
2082        };
2083
2084        //Create default context.
2085        req({});
2086
2087        //Exports some context-sensitive methods on global require.
2088        each([
2089            'toUrl',
2090            'undef',
2091            'defined',
2092            'specified'
2093        ], function (prop) {
2094            //Reference from contexts instead of early binding to default context,
2095            //so that during builds, the latest instance of the default context
2096            //with its config gets used.
2097            req[prop] = function () {
2098                var ctx = contexts[defContextName];
2099                return ctx.require[prop].apply(ctx, arguments);
2100            };
2101        });
2102
2103        if (isBrowser) {
2104            head = s.head = document.getElementsByTagName('head')[0];
2105            //If BASE tag is in play, using appendChild is a problem for IE6.
2106            //When that browser dies, this can be removed. Details in this jQuery bug:
2107            //http://dev.jquery.com/ticket/2709
2108            baseElement = document.getElementsByTagName('base')[0];
2109            if (baseElement) {
2110                head = s.head = baseElement.parentNode;
2111            }
2112        }
2113
2114        /**
2115         * Any errors that require explicitly generates will be passed to this
2116         * function. Intercept/override it if you want custom error handling.
2117         * @param {Error} err the error object.
2118         */
2119        req.onError = defaultOnError;
2120
2121        /**
2122         * Creates the node for the load command. Only used in browser envs.
2123         */
2124        req.createNode = function (config, moduleName, url) {
2125            var node = config.xhtml ?
2126                document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
2127                document.createElement('script');
2128            node.type = config.scriptType || 'text/javascript';
2129            node.charset = 'utf-8';
2130            node.async = true;
2131            return node;
2132        };
2133
2134        /**
2135         * Does the request to load a module for the browser case.
2136         * Make this a separate function to allow other environments
2137         * to override it.
2138         *
2139         * @param {Object} context the require context to find state.
2140         * @param {String} moduleName the name of the module.
2141         * @param {Object} url the URL to the module.
2142         */
2143        req.load = function (context, moduleName, url) {
2144            var config = (context && context.config) || {},
2145                node;
2146            if (isBrowser) {
2147                //In the browser so use a script tag
2148                node = req.createNode(config, moduleName, url);
2149
2150                node.setAttribute('data-requirecontext', context.contextName);
2151                node.setAttribute('data-requiremodule', moduleName);
2152
2153                //Set up load listener. Test attachEvent first because IE9 has
2154                //a subtle issue in its addEventListener and script onload firings
2155                //that do not match the behavior of all other browsers with
2156                //addEventListener support, which fire the onload event for a
2157                //script right after the script execution. See:
2158                //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
2159                //UNFORTUNATELY Opera implements attachEvent but does not follow the script
2160                //script execution mode.
2161                if (node.attachEvent &&
2162                    //Check if node.attachEvent is artificially added by custom script or
2163                    //natively supported by browser
2164                    //read https://github.com/requirejs/requirejs/issues/187
2165                    //if we can NOT find [native code] then it must NOT natively supported.
2166                    //in IE8, node.attachEvent does not have toString()
2167                    //Note the test for "[native code" with no closing brace, see:
2168                    //https://github.com/requirejs/requirejs/issues/273
2169                    !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
2170                    !isOpera) {
2171                    //Probably IE. IE (at least 6-8) do not fire
2172                    //script onload right after executing the script, so
2173                    //we cannot tie the anonymous define call to a name.
2174                    //However, IE reports the script as being in 'interactive'
2175                    //readyState at the time of the define call.
2176                    useInteractive = true;
2177
2178                    node.attachEvent('onreadystatechange', context.onScriptLoad);
2179                    //It would be great to add an error handler here to catch
2180                    //404s in IE9+. However, onreadystatechange will fire before
2181                    //the error handler, so that does not help. If addEventListener
2182                    //is used, then IE will fire error before load, but we cannot
2183                    //use that pathway given the connect.microsoft.com issue
2184                    //mentioned above about not doing the 'script execute,
2185                    //then fire the script load event listener before execute
2186                    //next script' that other browsers do.
2187                    //Best hope: IE10 fixes the issues,
2188                    //and then destroys all installs of IE 6-9.
2189                    //node.attachEvent('onerror', context.onScriptError);
2190                } else {
2191                    node.addEventListener('load', context.onScriptLoad, false);
2192                    node.addEventListener('error', context.onScriptError, false);
2193                }
2194                node.src = url;
2195
2196                //Calling onNodeCreated after all properties on the node have been
2197                //set, but before it is placed in the DOM.
2198                if (config.onNodeCreated) {
2199                    config.onNodeCreated(node, config, moduleName, url);
2200                }
2201
2202                //For some cache cases in IE 6-8, the script executes before the end
2203                //of the appendChild execution, so to tie an anonymous define
2204                //call to the module name (which is stored on the node), hold on
2205                //to a reference to this node, but clear after the DOM insertion.
2206                currentlyAddingScript = node;
2207                if (baseElement) {
2208                    head.insertBefore(node, baseElement);
2209                } else {
2210                    head.appendChild(node);
2211                }
2212                currentlyAddingScript = null;
2213
2214                return node;
2215            } else if (isWebWorker) {
2216                try {
2217                    //In a web worker, use importScripts. This is not a very
2218                    //efficient use of importScripts, importScripts will block until
2219                    //its script is downloaded and evaluated. However, if web workers
2220                    //are in play, the expectation is that a build has been done so
2221                    //that only one script needs to be loaded anyway. This may need
2222                    //to be reevaluated if other use cases become common.
2223
2224                    // Post a task to the event loop to work around a bug in WebKit
2225                    // where the worker gets garbage-collected after calling
2226                    // importScripts(): https://webkit.org/b/153317
2227                    setTimeout(function() {}, 0);
2228                    importScripts(url);
2229
2230                    //Account for anonymous modules
2231                    context.completeLoad(moduleName);
2232                } catch (e) {
2233                    context.onError(makeError('importscripts',
2234                        'importScripts failed for ' +
2235                        moduleName + ' at ' + url,
2236                        e,
2237                        [moduleName]));
2238                }
2239            }
2240        };
2241
2242        function getInteractiveScript() {
2243            if (interactiveScript && interactiveScript.readyState === 'interactive') {
2244                return interactiveScript;
2245            }
2246
2247            eachReverse(scripts(), function (script) {
2248                if (script.readyState === 'interactive') {
2249                    return (interactiveScript = script);
2250                }
2251            });
2252            return interactiveScript;
2253        }
2254
2255        //Look for a data-main script attribute, which could also adjust the baseUrl.
2256        if (isBrowser && !cfg.skipDataMain) {
2257            //Figure out baseUrl. Get it from the script tag with require.js in it.
2258            eachReverse(scripts(), function (script) {
2259                //Set the 'head' where we can append children by
2260                //using the script's parent.
2261                if (!head) {
2262                    head = script.parentNode;
2263                }
2264
2265                //Look for a data-main attribute to set main script for the page
2266                //to load. If it is there, the path to data main becomes the
2267                //baseUrl, if it is not already set.
2268                dataMain = script.getAttribute('data-main');
2269                if (dataMain) {
2270                    //Preserve dataMain in case it is a path (i.e. contains '?')
2271                    mainScript = dataMain;
2272
2273                    //Set final baseUrl if there is not already an explicit one,
2274                    //but only do so if the data-main value is not a loader plugin
2275                    //module ID.
2276                    if (!cfg.baseUrl && mainScript.indexOf('!') === -1) {
2277                        //Pull off the directory of data-main for use as the
2278                        //baseUrl.
2279                        src = mainScript.split('/');
2280                        mainScript = src.pop();
2281                        subPath = src.length ? src.join('/')  + '/' : './';
2282
2283                        cfg.baseUrl = subPath;
2284                    }
2285
2286                    //Strip off any trailing .js since mainScript is now
2287                    //like a module name.
2288                    mainScript = mainScript.replace(jsSuffixRegExp, '');
2289
2290                    //If mainScript is still a path, fall back to dataMain
2291                    if (req.jsExtRegExp.test(mainScript)) {
2292                        mainScript = dataMain;
2293                    }
2294
2295                    //Put the data-main script in the files to load.
2296                    cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];
2297
2298                    return true;
2299                }
2300            });
2301        }
2302
2303        /**
2304         * The function that handles definitions of modules. Differs from
2305         * require() in that a string for the module should be the first argument,
2306         * and the function to execute after dependencies are loaded should
2307         * return a value to define the module corresponding to the first argument's
2308         * name.
2309         */
2310        define = function (name, deps, callback) {
2311            var node, context;
2312
2313            //Allow for anonymous modules
2314            if (typeof name !== 'string') {
2315                //Adjust args appropriately
2316                callback = deps;
2317                deps = name;
2318                name = null;
2319            }
2320
2321            //This module may not have dependencies
2322            if (!isArray(deps)) {
2323                callback = deps;
2324                deps = null;
2325            }
2326