https://www.pni.md/static/version1651812064/_cache/merged/2e02063468aee756cb821c9871f88ffd.js

1/** vim: et:ts=4:sw=4:sts=4
2 * @license RequireJS 2.1.11 Copyright (c) 2010-2014, The Dojo Foundation All Rights Reserved.
3 * Available via the MIT or new BSD license.
4 * see: http://github.com/jrburke/requirejs for details
5 */
6//Not using strict: uneven strict support in browsers, #392, and causes
7//problems with requirejs.exec()/transpiler plugins that may not be strict.
8/*jslint regexp: true, nomen: true, sloppy: true */
9/*global window, navigator, document, importScripts, setTimeout, opera */
10
11var requirejs, require, define;
12(function (global) {
13    var req, s, head, baseElement, dataMain, src,
14        interactiveScript, currentlyAddingScript, mainScript, subPath,
15        version = '2.1.11',
16        commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
17        cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
18        jsSuffixRegExp = /\.js$/,
19        currDirRegExp = /^\.\//,
20        op = Object.prototype,
21        ostring = op.toString,
22        hasOwn = op.hasOwnProperty,
23        ap = Array.prototype,
24        apsp = ap.splice,
25        isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
26        isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
27        //PS3 indicates loaded and complete, but need to wait for complete
28        //specifically. Sequence is 'loading', 'loaded', execution,
29        // then 'complete'. The UA check is unfortunate, but not sure how
30        //to feature test w/o causing perf issues.
31        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
32                      /^complete$/ : /^(complete|loaded)$/,
33        defContextName = '_',
34        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
35        isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
36        contexts = {},
37        cfg = {},
38        globalDefQueue = [],
39        useInteractive = false;
40
41    function isFunction(it) {
42        return ostring.call(it) === '[object Function]';
43    }
44
45    function isArray(it) {
46        return ostring.call(it) === '[object Array]';
47    }
48
49    /**
50     * Helper function for iterating over an array. If the func returns
51     * a true value, it will break out of the loop.
52     */
53    function each(ary, func) {
54        if (ary) {
55            var i;
56            for (i = 0; i < ary.length; i += 1) {
57                if (ary[i] && func(ary[i], i, ary)) {
58                    break;
59                }
60            }
61        }
62    }
63
64    /**
65     * Helper function for iterating over an array backwards. If the func
66     * returns a true value, it will break out of the loop.
67     */
68    function eachReverse(ary, func) {
69        if (ary) {
70            var i;
71            for (i = ary.length - 1; i > -1; i -= 1) {
72                if (ary[i] && func(ary[i], i, ary)) {
73                    break;
74                }
75            }
76        }
77    }
78
79    function hasProp(obj, prop) {
80        return hasOwn.call(obj, prop);
81    }
82
83    function getOwn(obj, prop) {
84        return hasProp(obj, prop) && obj[prop];
85    }
86
87    /**
88     * Cycles over properties in an object and calls a function for each
89     * property value. If the function returns a truthy value, then the
90     * iteration is stopped.
91     */
92    function eachProp(obj, func) {
93        var prop;
94        for (prop in obj) {
95            if (hasProp(obj, prop)) {
96                if (func(obj[prop], prop)) {
97                    break;
98                }
99            }
100        }
101    }
102
103    /**
104     * Simple function to mix in properties from source into target,
105     * but only if target does not already have a property of the same name.
106     */
107    function mixin(target, source, force, deepStringMixin) {
108        if (source) {
109            eachProp(source, function (value, prop) {
110                if (force || !hasProp(target, prop)) {
111                    if (deepStringMixin && typeof value === 'object' && value &&
112                        !isArray(value) && !isFunction(value) &&
113                        !(value instanceof RegExp)) {
114
115                        if (!target[prop]) {
116                            target[prop] = {};
117                        }
118                        mixin(target[prop], value, force, deepStringMixin);
119                    } else {
120                        target[prop] = value;
121                    }
122                }
123            });
124        }
125        return target;
126    }
127
128    //Similar to Function.prototype.bind, but the 'this' object is specified
129    //first, since it is easier to read/figure out what 'this' will be.
130    function bind(obj, fn) {
131        return function () {
132            return fn.apply(obj, arguments);
133        };
134    }
135
136    function scripts() {
137        return document.getElementsByTagName('script');
138    }
139
140    function defaultOnError(err) {
141        throw err;
142    }
143
144    //Allow getting a global that is expressed in
145    //dot notation, like 'a.b.c'.
146    function getGlobal(value) {
147        if (!value) {
148            return value;
149        }
150        var g = global;
151        each(value.split('.'), function (part) {
152            g = g[part];
153        });
154        return g;
155    }
156
157    /**
158     * Constructs an error with a pointer to an URL with more information.
159     * @param {String} id the error ID that maps to an ID on a web page.
160     * @param {String} message human readable error.
161     * @param {Error} [err] the original error, if there is one.
162     *
163     * @returns {Error}
164     */
165    function makeError(id, msg, err, requireModules) {
166        var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
167        e.requireType = id;
168        e.requireModules = requireModules;
169        if (err) {
170            e.originalError = err;
171        }
172        return e;
173    }
174
175    if (typeof define !== 'undefined') {
176        //If a define is already in play via another AMD loader,
177        //do not overwrite.
178        return;
179    }
180
181    if (typeof requirejs !== 'undefined') {
182        if (isFunction(requirejs)) {
183            //Do not overwrite and existing requirejs instance.
184            return;
185        }
186        cfg = requirejs;
187        requirejs = undefined;
188    }
189
190    //Allow for a require config object
191    if (typeof require !== 'undefined' && !isFunction(require)) {
192        //assume it is a config object.
193        cfg = require;
194        require = undefined;
195    }
196
197    function newContext(contextName) {
198        var inCheckLoaded, Module, context, handlers,
199            checkLoadedTimeoutId,
200            config = {
201                //Defaults. Do not set a default for map
202                //config to speed up normalize(), which
203                //will run faster if there is no default.
204                waitSeconds: 7,
205                baseUrl: './',
206                paths: {},
207                bundles: {},
208                pkgs: {},
209                shim: {},
210                config: {}
211            },
212            registry = {},
213            //registry of just enabled modules, to speed
214            //cycle breaking code when lots of modules
215            //are registered, but not activated.
216            enabledRegistry = {},
217            undefEvents = {},
218            defQueue = [],
219            defined = {},
220            urlFetched = {},
221            bundlesMap = {},
222            requireCounter = 1,
223            unnormalizedCounter = 1;
224
225        /**
226         * Trims the . and .. from an array of path segments.
227         * It will keep a leading path segment if a .. will become
228         * the first path segment, to help with module name lookups,
229         * which act like paths, but can be remapped. But the end result,
230         * all paths that use this function should look normalized.
231         * NOTE: this method MODIFIES the input array.
232         * @param {Array} ary the array of path segments.
233         */
234        function trimDots(ary) {
235            var i, part, length = ary.length;
236            for (i = 0; i < length; i++) {
237                part = ary[i];
238                if (part === '.') {
239                    ary.splice(i, 1);
240                    i -= 1;
241                } else if (part === '..') {
242                    if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
243                        //End of the line. Keep at least one non-dot
244                        //path segment at the front so it can be mapped
245                        //correctly to disk. Otherwise, there is likely
246                        //no path mapping for a path starting with '..'.
247                        //This can still fail, but catches the most reasonable
248                        //uses of ..
249                        break;
250                    } else if (i > 0) {
251                        ary.splice(i - 1, 2);
252                        i -= 2;
253                    }
254                }
255            }
256        }
257
258        /**
259         * Given a relative module name, like ./something, normalize it to
260         * a real name that can be mapped to a path.
261         * @param {String} name the relative name
262         * @param {String} baseName a real name that the name arg is relative
263         * to.
264         * @param {Boolean}

327                                    //Match, update name to the new value.
328                                    foundMap = mapValue;
329                                    foundI = i;
330                                    break outerLoop;
331                                }
332                            }
333                        }
334                    }
335
336                    //Check for a star map match, but just hold on to it,
337                    //if there is a shorter segment match later in a matching
338                    //config, then favor over this star map.
339                    if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
340                        foundStarMap = getOwn(starMap, nameSegment);
341                        starI = i;
342                    }
343                }
344
345                if (!foundMap && foundStarMap) {
346                    foundMap = foundStarMap;
347                    foundI = starI;
348                }
349
350                if (foundMap) {
351                    nameParts.splice(0, foundI, foundMap);
352                    name = nameParts.join('/');
353                }
354            }
355
356            // If the name points to a package's name, use
357            // the package main instead.
358            pkgMain = getOwn(config.pkgs, name);
359
360            return pkgMain ? pkgMain : name;
361        }
362
363        function removeScript(name) {
364            if (isBrowser) {
365                each(scripts(), function (scriptNode) {
366                    if (scriptNode.getAttribute('data-requiremodule') === name &&
367                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
368                        scriptNode.parentNode.removeChild(scriptNode);
369                        return true;
370                    }
371                });
372            }
373        }
374
375        function hasPathFallback(id) {
376            var pathConfig = getOwn(config.paths, id);
377            if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
378                //Pop off the first array value, since it failed, and
379                //retry
380                pathConfig.shift();
381                context.require.undef(id);
382                context.require([id]);
383                return true;
384            }
385        }
386
387        //Turns a plugin!resource to [plugin, resource]
388        //with the plugin being undefined if the name
389        //did not have a plugin prefix.
390        function splitPrefix(name) {
391            var prefix,
392                index = name ? name.indexOf('!') : -1;
393            if (index > -1) {
394                prefix = name.substring(0, index);
395                name = name.substring(index + 1, name.length);
396            }
397            return [prefix, name];
398        }
399
400        /**
401         * Creates a module mapping that includes plugin prefix, module
402         * name, and path. If parentModuleMap is provided it will
403         * also normalize the name via require.normalize()
404         *
405         * @param {String} name the module name
406         * @param {String} [parentModuleMap] parent module map
407         * for the module name, used to resolve relative names.
408         * @param {Boolean} isNormalized: is the ID already normalized.
409         * This is true if this call is done for a define() module ID.
410         * @param {Boolean} applyMap: apply the map config to the ID.
411         * Should only be true if this map is for a dependency.
412         *
413         * @returns {Object}
414         */
415        function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
416            var url, pluginModule, suffix, nameParts,
417                prefix = null,
418                parentName = parentModuleMap ? parentModuleMap.name : null,
419                originalName = name,
420                isDefine = true,
421                normalizedName = '';
422
423            //If no name, then it means it is a require call, generate an
424            //internal name.
425            if (!name) {
426                isDefine = false;
427                name = '_@r' + (requireCounter += 1);
428            }
429
430            nameParts = splitPrefix(name);
431            prefix = nameParts[0];
432            name = nameParts[1];
433
434            if (prefix) {
435                prefix = normalize(prefix, parentName, applyMap);
436                pluginModule = getOwn(defined, prefix);
437            }
438
439            //Account for relative paths if there is a base name.
440            if (name) {
441                if (prefix) {
442                    if (pluginModule && pluginModule.normalize) {
443                        //Plugin is loaded, use its normalize method.
444                        normalizedName = pluginModule.normalize(name, function (name) {
445                            return normalize(name, parentName, applyMap);
446                        });
447                    } else {

569                    if (mod.exports) {
570                        return (defined[mod.map.id] = mod.exports);
571                    } else {
572                        return (mod.exports = defined[mod.map.id] = {});
573                    }
574                }
575            },
576            'module': function (mod) {
577                if (mod.module) {
578                    return mod.module;
579                } else {
580                    return (mod.module = {
581                        id: mod.map.id,
582                        uri: mod.map.url,
583                        config: function () {
584                            return  getOwn(config.config, mod.map.id) || {};
585                        },
586                        exports: mod.exports || (mod.exports = {})
587                    });
588                }
589            }
590        };
591
592        function cleanRegistry(id) {
593            //Clean up machinery used for waiting modules.
594            delete registry[id];
595            delete enabledRegistry[id];
596        }
597
598        function breakCycle(mod, traced, processed) {
599            var id = mod.map.id;
600
601            if (mod.error) {
602                mod.emit('error', mod.error);
603            } else {
604                traced[id] = true;
605                each(mod.depMaps, function (depMap, i) {
606                    var depId = depMap.id,
607                        dep = getOwn(registry, depId);
608
609                    //Only force things that have not completed
610                    //being defined, so still in the registry,
611                    //and only if it has not been matched up
612                    //in the module already.
613                    if (dep && !mod.depMatched[i] && !processed[depId]) {
614                        if (getOwn(traced, depId)) {
615                            mod.defineDep(i, defined[depId]);
616                            mod.check(); //pass false?
617                        } else {
618                            breakCycle(dep, traced, processed);
619                        }
620                    }
621                });
622                processed[id] = true;
623            }
624        }
625
626        function checkLoaded() {
627            var err, usingPathFallback,
628                waitInterval = config.waitSeconds * 1000,
629                //It is possible to disable the wait interval by using waitSeconds of 0.
630                expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
631                noLoads = [],
632                reqCalls = [],
633                stillLoading = false,
634                needCycleCheck = true;
635
636            //Do not bother if this call was a result of a cycle break.
637            if (inCheckLoaded) {
638                return;
639            }
640
641            inCheckLoaded = true;
642
643            //Figure out the state of all the modules.
644            eachProp(enabledRegistry, function (mod) {
645                var map = mod.map,
646                    modId = map.id;
647
648                //Skip things that are not enabled or in error state.
649                if (!mod.enabled) {
650                    return;
651                }
652
653                if (!map.isDefine) {
654                    reqCalls.push(mod);
655                }
656
657                if (!mod.error) {
658                    //If the module should be executed, and it has not
659                    //been inited and time is up, remember it.
660                    if (!mod.inited && expired) {
661                        if (hasPathFallback(modId)) {
662                            usingPathFallback = true;
663                            stillLoading = true;
664                        } else {
665                            noLoads.push(modId);
666                            removeScript(modId);
667                        }
668                    } else if (!mod.inited && mod.fetched && map.isDefine) {
669                        stillLoading = true;
670                        if (!map.prefix) {
671                            //No reason to keep looking for unfinished
672                            //loading. If the only stillLoading is a
673                            //plugin resource though, keep going,
674                            //because it may be that a plugin resource
675                            //is waiting on a non-plugin cycle.
676                            return (needCycleCheck = false);
677                        }
678                    }
679                }
680            });
681
682            if (expired && noLoads.length) {
683                //If wait time expired, throw error of unloaded modules.
684                err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
685                err.contextName = context.contextName;
686                return onError(err);
687            }
688
689            //Not expired, check for a cycle.
690            if (needCycleCheck) {
691                each(reqCalls, function (mod) {
692                    breakCycle(mod, {}, {});
693                });
694            }
695
696            //If still waiting on loads, and the waiting load is something
697            //other than a plugin resource, or there are still outstanding
698            //scripts, then just try back later.
699            if ((!expired || usingPathFallback) && stillLoading) {
700                //Something is still waiting to load. Wait for it, but only
701                //if a timeout is not already in effect.
702                if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
703                    checkLoadedTimeoutId = setTimeout(function () {
704                        checkLoadedTimeoutId = 0;
705                        checkLoaded();
706                    }, 50);
707                }
708            }
709
710            inCheckLoaded = false;
711        }
712
713        Module = function (map) {
714            this.events = getOwn(undefEvents, map.id) || {};
715            this.map = map;
716            this.shim = getOwn(config.shim, map.id);
717            this.depExports = [];
718            this.depMaps = [];
719            this.depMatched = [];
720            this.pluginMaps = {};
721            this.depCount = 0;
722
723            /* this.exports this.factory
724               this.depMaps = [],
725               this.enabled, this.fetched
726            */
727        };
728
729        Module.prototype = {
730            init: function (depMaps, factory, errback, options) {
731                options = options || {};
732
733                //Do not do more inits if already done. Can happen if there
734                //are multiple define calls for the same module. That is not
735                //a normal, common case, but it is also not unexpected.
736                if (this.inited) {
737                    return;
738                }
739
740                this.factory = factory;
741
742                if (errback) {
743                    //Register for errors on this module.
744                    this.on('error', errback);
745                } else if (this.events.error) {
746                    //If no errback already, but there are error listeners
747                    //on this module, set up an errback to pass to the deps.
748                    errback = bind(this, function (err) {
749                        this.emit('error', err);
750                    });
751                }
752
753                //Do a copy of the dependency array, so that
754                //source inputs are not modified. For example
755                //"shim" deps are passed in here directly, and
756                //doing a direct modification of the depMaps array
757                //would affect that config.
758                this.depMaps = depMaps && depMaps.slice(0);
759
760                this.errback = errback;
761
762                //Indicate this module has be initialized
763                this.inited = true;
764
765                this.ignore = options.ignore;
766
767                //Could have option to init this module in enabled mode,
768                //or could have been previously marked as enabled. However,
769                //the dependencies are not known until init is called. So
770                //if enabled previously, now trigger dependencies as enabled.
771                if (options.enabled || this.enabled) {
772                    //Enable this module and dependencies.
773                    //Will call this.check()
774                    this.enable();
775                } else {
776                    this.check();
777                }
778            },
779
780            defineDep: function (i, depExports) {
781                //Because of cycles, defined callback for a given
782                //export can be called more than once.
783                if (!this.depMatched[i]) {
784                    this.depMatched[i] = true;
785                    this.depCount -= 1;
786                    this.depExports[i] = depExports;
787                }
788            },
789
790            fetch: function () {
791                if (this.fetched) {
792                    return;
793                }
794                this.fetched = true;
795
796                context.startTime = (new Date()).getTime();
797
798                var map = this.map;
799
800                //If the manager is for a plugin managed resource,
801                //ask the plugin to load it now.
802                if (this.shim) {
803                    context.makeRequire(this.map, {
804                        enableBuildCallback: true
805                    })(this.shim.deps || [], bind(this, function () {
806                        return map.prefix ? this.callPlugin() : this.load();
807                    }));
808                } else {
809                    //Regular dependency.
810                    return map.prefix ? this.callPlugin() : this.load();
811                }
812            },
813
814            load: function () {
815                var url = this.map.url;
816
817                //Regular dependency.
818                if (!urlFetched[url]) {
819                    urlFetched[url] = true;
820                    context.load(this.map.id, url);
821                }
822            },
823
824            /**
825             * Checks if the module is ready to define itself, and if so,
826             * define it.
827             */
828            check: function () {
829                if (!this.enabled || this.enabling) {
830                    return;
831                }
832
833                var err, cjsModule,
834                    id = this.map.id,
835                    depExports = this.depExports,
836                    exports = this.exports,
837                    factory = this.factory;
838
839                if (!this.inited) {
840                    this.fetch();
841                } else if (this.error) {
842                    this.emit('error', this.error);
843                } else if (!this.defining) {
844                    //The factory could trigger another require call
845                    //that would result in checking this module to
846                    //define itself again. If already in the process
847                    //of doing that, skip this work.
848                    this.defining = true;
849
850                    if (this.depCount < 1 && !this.defined) {
851                        if (isFunction(factory)) {
852                            //If there is an error listener, favor passing
853                            //to that instead of throwing an error. However,
854                            //only do it for define()'d  modules. require
855                            //errbacks should not be called for failures in
856                            //their callbacks (#699). However if a global
857                            //onError is set, use that.
858                            if ((this.events.error && this.map.isDefine) ||
859                                req.onError !== defaultOnError) {
860                                try {
861                                    exports = context.execCb(id, factory, depExports, exports);
862                                } catch (e) {
863                                    err = e;
864                                }
865                            } else {
866                                exports = context.execCb(id, factory, depExports, exports);
867                            }
868
869                            // Favor return value over exports. If node/cjs in play,
870                            // then will not have a return value anyway. Favor
871                            // module.exports assignment over exports object.
872                            if (this.map.isDefine && exports === undefined) {
873                                cjsModule = this.module;
874                                if (cjsModule) {
875                                    exports = cjsModule.exports;
876                                } else if (this.usingExports) {
877                                    //exports already set the defined value.
878                                    exports = this.exports;
879                                }
880                            }
881
882                            if (err) {
883                                err.requireMap = this.map;
884                                err.requireModules = this.map.isDefine ? [this.map.id] : null;
885                                err.requireType = this.map.isDefine ? 'define' : 'require';
886                                return onError((this.error = err));
887                            }
888
889                        } else {
890                            //Just a literal value
891                            exports = factory;
892                        }
893
894                        this.exports = exports;
895
896                        if (this.map.isDefine && !this.ignore) {
897                            defined[id] = exports;
898
899                            if (req.onResourceLoad) {
900                                req.onResourceLoad(context, this.map, this.depMaps);
901                            }
902                        }
903
904                        //Clean up
905                        cleanRegistry(id);
906
907                        this.defined = true;
908                    }
909
910                    //Finished the define stage. Allow calling check again
911                    //to allow define notifications below in the case of a
912                    //cycle.
913                    this.defining = false;
914
915                    if (this.defined && !this.defineEmitted) {
916                        this.defineEmitted = true;
917                        this.emit('defined', this.exports);
918                        this.defineEmitComplete = true;
919                    }
920
921                }
922            },
923
924            callPlugin: function () {
925                var map = this.map,
926                    id = map.id,
927                    //Map already normalized the prefix.
928                    pluginMap = makeModuleMap(map.prefix);
929
930                //Mark this as a dependency for this plugin, so it
931                //can be traced for cycles.
932                this.depMaps.push(pluginMap);
933
934                on(pluginMap, 'defined', bind(this, function (plugin) {
935                    var load, normalizedMap, normalizedMod,
936                        bundleId = getOwn(bundlesMap, this.map.id),
937                        name = this.map.name,
938                        parentName = this.map.parentMap ? this.map.parentMap.name : null,
939                        localRequire = context.makeRequire(map.parentMap, {
940                            enableBuildCallback: true
941                        });
942
943                    //If current map is not normalized, wait for that
944                    //normalized name to load instead of continuing.
945                    if (this.map.unnormalized) {
946                        //Normalize the ID if the plugin allows it.
947                        if (plugin.normalize) {
948                            name = plugin.normalize(name, function (name) {
949                                return normalize(name, parentName, true);
950                            }) || '';
951                        }
952
953                        //prefix and name should already be normalized, no need
954                        //for applying map config again either.
955                        normalizedMap = makeModuleMap(map.prefix + '!' + name,
956                                                      this.map.parentMap);
957                        on(normalizedMap,
958                            'defined', bind(this, function (value) {

958
959                                this.init([], function () { return value; }, null, {
960                                    enabled: true,
961                                    ignore: true
962                                });
963                            }));
964
965                        normalizedMod = getOwn(registry, normalizedMap.id);
966                        if (normalizedMod) {
967                            //Mark this as a dependency for this plugin, so it
968                            //can be traced for cycles.
969                            this.depMaps.push(normalizedMap);
970
971                            if (this.events.error) {
972                                normalizedMod.on('error', bind(this, function (err) {
973                                    this.emit('error', err);
974                                }));
975                            }
976                            normalizedMod.enable();
977                        }
978
979                        return;
980                    }
981
982                    //If a paths config, then just load that file instead to
983                    //resolve the plugin, as it is built into that paths layer.
984                    if (bundleId) {
985                        this.map.url = context.nameToUrl(bundleId);
986                        this.load();
987                        return;
988                    }
989
990                    load = bind(this, function (value) {
991                        this.init([], function () { return value; }, null, {
992                            enabled: true
993                        });
994                    });
995
996                    load.error = bind(this, function (err) {
997                        this.inited = true;
998                        this.error = err;
999                        err.requireModules = [id];
1000
1001                        //Remove temp unnormalized modules for this module,
1002                        //since they will never be resolved otherwise now.
1003                        eachProp(registry, function (mod) {
1004                            if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
1005                                cleanRegistry(mod.map.id);
1006                            }
1007                        });
1008
1009                        onError(err);
1010                    });
1011
1012                    //Allow plugins to load other code without having to know the
1013                    //context or how to 'complete' the load.
1014                    load.fromText = bind(this, function (text, textAlt) {
1015                        /*jslint evil: true */
1016                        var moduleName = map.name,
1017                            moduleMap = makeModuleMap(moduleName),
1018                            hasInteractive = useInteractive;
1019
1020                        //As of 2.1.0, support just passing the text, to reinforce
1021                        //fromText only being called once per resource. Still
1022                        //support old style of passing moduleName but discard
1023                        //that moduleName in favor of the internal ref.
1024                        if (textAlt) {
1025                            text = textAlt;
1026                        }
1027
1028                        //Turn off interactive script matching for IE for any define
1029                        //calls in the text, then turn it back on at the end.
1030                        if (hasInteractive) {
1031                            useInteractive = false;
1032                        }
1033
1034                        //Prime the system by creating a module instance for
1035                        //it.
1036                        getModule(moduleMap);
1037
1038                        //Transfer any config to this other module.
1039                        if (hasProp(config.config, id)) {
1040                            config.config[moduleName] = config.config[id];
1041                        }
1042
1043                        try {
1044                            req.exec(text);
1045                        } catch (e) {
1046                            return onError(makeError('fromtexteval',
1047                                             'fromText eval for ' + id +
1048                                            ' failed: ' + e,
1049                                             e,
1050                                             [id]));
1051                        }
1052
1053                        if (hasInteractive) {
1054                            useInteractive = true;
1055                        }
1056
1057                        //Mark this as a dependency for the plugin
1058                        //resource
1059                        this.depMaps.push(moduleMap);
1060
1061                        //Support anonymous modules.
1062                        context.completeLoad(moduleName);
1063
1064                        //Bind the value of that module to the value for this
1065                        //resource ID.
1066                        localRequire([moduleName], load);
1067                    });
1068
1069                    //Use parentName here since the plugin's name is not reliable,
1070                    //could be some weird string with no path that actually wants to
1071                    //reference the parentName's path.
1072                    plugin.load(map.name, localRequire, load, config);
1073                }));
1074
1075                context.enable(pluginMap, this);
1076                this.pluginMaps[pluginMap.id] = pluginMap;
1077            },
1078
1079            enable: function () {
1080                enabledRegistry[this.map.id] = this;
1081                this.enabled = true;
1082
1083                //Set flag mentioning that the module is enabling,
1084                //so that immediate calls to the defined callbacks
1085                //for dependencies do not trigger inadvertent load
1086                //with the depCount still being zero.
1087                this.enabling = true;
1088
1089                //Enable each dependency
1090                each(this.depMaps, bind(this, function (depMap, i) {
1091                    var id, mod, handler;
1092
1093                    if (typeof depMap === 'string') {
1094                        //Dependency needs to be converted to a depMap
1095                        //and wired up to this module.
1096                        depMap = makeModuleMap(depMap,
1097                                               (this.map.isDefine ? this.map : this.map.parentMap),
1098                                               false,
1099                                               !this.skipMap);
1100                        this.depMaps[i] = depMap;
1101
1102                        handler = getOwn(handlers, depMap.id);
1103
1104                        if (handler) {
1105                            this.depExports[i] = handler(this);
1106                            return;
1107                        }
1108
1109                        this.depCount += 1;
1110
1111                        on(depMap, 'defined', bind(this, function (depExports) {
1112                            

1133                //a dependency
1134                eachProp(this.pluginMaps, bind(this, function (pluginMap) {
1135                    var mod = getOwn(registry, pluginMap.id);
1136                    if (mod && !mod.enabled) {
1137                        context.enable(pluginMap, this);
1138                    }
1139                }));
1140
1141                this.enabling = false;
1142
1143                this.check();
1144            },
1145
1146            on: function (name, cb) {
1147                var cbs = this.events[name];
1148                if (!cbs) {
1149                    cbs = this.events[name] = [];
1150                }
1151                cbs.push(cb);
1152            },
1153
1154            emit: function (name, evt) {
1155                each(this.events[name], function (cb) {
1156                    cb(evt);
1157                });
1158                if (name === 'error') {
1159                    //Now that the error handler was triggered, remove
1160                    //the listeners, since this broken Module instance
1161                    //can stay around for a while in the registry.
1162                    delete this.events[name];
1163                }
1164            }
1165        };
1166
1167        function callGetModule(args) {
1168            //Skip modules already defined.
1169            if (!hasProp(defined, args[0])) {
1170                getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
1171            }
1172        }
1173
1174        function removeListener(node, func, name, ieName) {
1175            //Favor detachEvent because of IE9
1176            //issue, see attachEvent/addEventListener comment elsewhere
1177            //in this file.
1178            if (node.detachEvent && !isOpera) {
1179                //Probably IE. If not it will throw an error, which will be
1180                //useful to know.
1181                if (ieName) {
1182                    node.detachEvent(ieName, func);
1183                }
1184            } else {
1185                node.removeEventListener(name, func, false);
1186            }
1187        }
1188
1189        /**
1190         * Given an event from a script node, get the requirejs info from it,
1191         * and then removes the event listeners on the node.
1192         * @param {Event} evt
1193         * @returns {Object}
1194         */
1195        function getScriptData(evt) {
1196            //Using currentTarget instead of target for Firefox 2.0's sake. Not
1197            //all old browsers will be supported, but this one was easy enough
1198            //to support and still makes sense.
1199            var node = evt.currentTarget || evt.srcElement;
1200
1201            //Remove the listeners once here.
1202            removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
1203            removeListener(node, context.onScriptError, 'error');
1204
1205            return {
1206                node: node,
1207                id: node && node.getAttribute('data-requiremodule')
1208            };
1209        }
1210
1211        function intakeDefines() {
1212            var args;
1213
1214            //Any defined modules in the global queue, intake them now.
1215            takeGlobalQueue();
1216
1217            //Make sure any remaining defQueue items get properly processed.
1218            while (defQueue.length) {
1219                args = defQueue.shift();
1220                if (args[0] === null) {
1221                    return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
1222                } else {
1223                    //args are id, deps, factory. Should be normalized by the
1224                    //define() function.
1225                    callGetModule(args);
1226                }
1227            }
1228        }
1229
1230        context = {
1231            config: config,
1232            contextName: contextName,
1233            registry: registry,
1234            defined: defined,
1235            urlFetched: urlFetched,
1236            defQueue: defQueue,
1237            Module: Module,
1238            makeModuleMap: makeModuleMap,
1239            nextTick: req.nextTick,
1240            onError: onError,
1241
1242            /**
1243             * Set a configuration for the context.
1244             * @param {Object} cfg config object to integrate.
1245             */
1246            configure: function (cfg) {
1247                //Make sure the baseUrl ends in a slash.
1248                if (cfg.baseUrl) {
1249                    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
1250                        cfg.baseUrl += '/';
1251                    }
1252                }
1253
1254                //Save off the paths since they require special processing,
1255                //they are additive.
1256                var shim = config.shim,
1257                    objs = {
1258                        paths: true,
1259                        bundles: true,
1260                        config: true,
1261                        map: true
1262                    };
1263
1264                eachProp(cfg, function (value, prop) {
1265                    if (objs[prop]) {
1266                        if (!config[prop]) {
1267                            config[prop] = {};
1268                        }
1269                        mixin(config[prop], value, true, true);
1270                    } else {
1271                        config[prop] = value;
1272                    }
1273                });
1274
1275                //Reverse map the bundles
1276                if (cfg.bundles) {
1277                    eachProp(cfg.bundles, function (value, prop) {
1278                        each(value, function (v) {
1279                            if (v !== prop) {
1280                                bundlesMap[v] = prop;
1281                            }
1282                        });
1283                    });
1284                }
1285
1286                //Merge shim
1287                if (cfg.shim) {
1288                    eachProp(cfg.shim, function (value, id) {
1289                        //Normalize the structure
1290                        if (isArray(value)) {
1291                            value = {
1292                                deps: value
1293                            };
1294                        }
1295                        if ((value.exports || value.init) && !value.exportsFn) {
1296                            value.exportsFn = context.makeShimExports(value);
1297                        }
1298                        shim[id] = value;
1299                    });
1300                    config.shim = shim;
1301                }
1302
1303                //Adjust packages if necessary.
1304                if (cfg.packages) {
1305                    each(cfg.packages, function (pkgObj) {
1306                        var location, name;
1307
1308                        pkgObj = typeof pkgObj === 'string' ? { name: pkgObj } : pkgObj;
1309
1310                        name = pkgObj.name;
1311                        location = pkgObj.location;
1312                        if (location) {
1313                            config.paths[name] = pkgObj.location;
1314                        }
1315
1316                        //Save pointer to main module ID for pkg name.
1317                        //Remove leading dot in main, so main paths are normalized,
1318                        //and remove any trailing .js, since different package
1319                        //envs have different conventions: some use a module name,
1320                        //some use a file name.
1321                        config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
1322                                     .replace(currDirRegExp, '')
1323                                     .replace(jsSuffixRegExp, '');
1324                    });
1325                }
1326
1327                //If there are any "waiting to execute" modules in the registry,
1328                //update the maps for them, since their info, like URLs to load,
1329                //may have changed.
1330                eachProp(registry, function (mod, id) {
1331                    //If module already has init called, since it is too
1332                    //late to modify them, and ignore unnormalized ones
1333                    //since they are transient.
1334                    if (!mod.inited && !mod.map.unnormalized) {
1335                        mod.map = makeModuleMap(id);
1336                    }
1337                });
1338
1339                //If a deps array or a config callback is specified, then call
1340                //require with those args. This is useful when require is defined as a
1341                //config object before require.js is loaded.
1342                if (cfg.deps || cfg.callback) {
1343                    context.require(cfg.deps || [], cfg.callback);
1344                }
1345            },
1346
1347            makeShimExports: function (value) {
1348                function fn() {
1349                    var ret;
1350                    if (value.init) {
1351                        ret = value.init.apply(global, arguments);
1352                    }
1353                    return ret || (value.exports && getGlobal(value.exports));
1354                }
1355                return fn;
1356            },
1357
1358            makeRequire: function (relMap, options) {
1359                options = options || {};
1360
1361                function localRequire(deps, callback, errback) {
1362                    var id, map, requireMod;
1363
1364                    if (options.enableBuildCallback && callback && isFunction(callback)) {
1365                        callback.__requireJsBuild = true;
1366                    }
1367
1368                    if (typeof deps === 'string') {
1369                        if (isFunction(callback)) {
1370                            //Invalid call
1371                            return onError(makeError('requireargs', 'Invalid require call'), errback);
1372                        }
1373
1374                        //If require|exports|module are requested, get the
1375                        //value for them from the special handlers. Caveat:
1376                        //this only works while module is being defined.
1377                        if (relMap && hasProp(handlers, deps)) {
1378                            return handlers[deps](registry[relMap.id]);
1379                        }
1380
1381                        //Synchronous access to one module. If require.get is
1382                        //available (as in the Node adapter), prefer that.
1383                        if (req.get) {
1384                            return req.get(context, deps, relMap, localRequire);
1385                        }
1386
1387                        //Normalize module name, if it contains . or ..
1388                        map = makeModuleMap(deps, relMap, false, true);
1389                        id = map.id;
1390
1391                        if (!hasProp(defined, id)) {
1392                            return onError(makeError('notloaded', 'Module name "' +
1393                                        id +
1394                                        '" has not been loaded yet for context: ' +
1395                                        contextName +
1396                                        (relMap ? '' : '. Use require([])')));
1397                        }
1398                        return defined[id];
1399                    }
1400
1401                    //Grab defines waiting in the global queue.
1402                    intakeDefines();
1403
1404                    //Mark all the dependencies as needing to be loaded.
1405                    context.nextTick(function () {
1406                        //Some defines could have been added since the
1407                        //require call, collect them.
1408                        intakeDefines();
1409
1410                        requireMod = getModule(makeModuleMap(null, relMap));
1411
1412                        //Store if map config should be applied to this require
1413                        //call for dependencies.
1414                        requireMod.skipMap = options.skipMap;
1415
1416                        requireMod.init(deps, callback, errback, {
1417                            enabled: true
1418                        });
1419
1420                        checkLoaded();
1421                    });
1422
1423                    return localRequire;
1424                }
1425
1426                mixin(localRequire, {
1427                    isBrowser: isBrowser,
1428
1429                    /**
1430                     * Converts a module name + .extension into an URL path.
1431                     * *Requires* the use of a module name. It does not support using
1432                     * plain URLs like nameToUrl.
1433                     */
1434                    toUrl: function (moduleNamePlusExt) {
1435                        var ext,
1436                            index = moduleNamePlusExt.lastIndexOf('.'),
1437                            segment = moduleNamePlusExt.split('/')[0],
1438                            isRelative = segment === '.' || segment === '..';
1439
1440                        //Have a file extension alias, and it is not the
1441                        //dots from a relative path.
1442                        if (index !== -1 && (!isRelative || index > 1)) {
1443                            ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
1444                            moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
1445                        }
1446
1447                        return context.nameToUrl(normalize(moduleNamePlusExt,
1448                                                relMap && relMap.id, true), ext,  true);
1449                    },
1450
1451                    defined: function (id) {
1452                        return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
1453                    },
1454
1455                    specified: function (id) {
1456                        id = makeModuleMap(id, relMap, false, true).id;
1457                        return hasProp(defined, id) || hasProp(registry, id);
1458                    }
1459                });
1460
1461                //Only allow undef on top level require calls
1462                if (!relMap) {
1463                    localRequire.undef = function (id) {
1464                        //Bind any waiting define() calls to this context,
1465                        //fix for #408
1466                        takeGlobalQueue();
1467
1468                        var map = makeModuleMap(id, relMap, true),
1469                            mod = getOwn(registry, id);
1470
1471                        removeScript(id);
1472
1473                        delete defined[id];
1474                        delete urlFetched[map.url];
1475                        delete undefEvents[id];
1476
1477                        //Clean queued defines too. Go backwards
1478                        //in array so that the splices do not
1479                        //mess up the iteration.
1480                        eachReverse(defQueue, function(args, i) {
1481                            if(args[0] === id) {
1482                                defQueue.splice(i, 1);
1483                            }
1484                        });
1485
1486                        if (mod) {
1487                            //Hold on to listeners in case the
1488                            //module will be attempted to be reloaded
1489                            //using a different config.
1490                            if (mod.events.defined) {
1491                                undefEvents[id] = mod.events;
1492                            }
1493
1494                            cleanRegistry(id);
1495                        }
1496                    };
1497                }
1498
1499                return localRequire;
1500            },
1501
1502            /**
1503             * Called to enable a module if it is still in the registry
1504             * awaiting enablement. A second arg, parent, the parent module,
1505             * is passed in for context, when this method is overridden by
1506             * the optimizer. Not shown here to keep code compact.
1507             */
1508            enable: function (depMap) {
1509                var mod = getOwn(registry, depMap.id);
1510                if (mod) {
1511                    getModule(depMap).enable();
1512                }
1513            },
1514
1515            /**
1516             * Internal method used by environment adapters to complete a load event.
1517             * A load event could be a script load or just a load pass from a synchronous
1518             * load call.
1519             * @param {String} moduleName the name of the module to potentially complete.
1520             */
1521            completeLoad: function (moduleName) {
1522                var found, args, mod,
1523                    shim = getOwn(config.shim, moduleName) || {},
1524                    shExports = shim.exports;
1525
1526                takeGlobalQueue();
1527
1528                while (defQueue.length) {
1529                    args = defQueue.shift();
1530                    if (args[0] === null) {
1531                        args[0] = moduleName;
1532                        //If already found an anonymous module and bound it
1533                        //to this name, then this is some other anon module
1534                        //waiting for its completeLoad to fire.
1535                        if (found) {
1536                            break;
1537                        }
1538                        found = true;
1539                    } else if (args[0] === moduleName) {
1540                        //Found matching define call for this script!
1541                        found = true;
1542                    }
1543
1544                    callGetModule(args);
1545                }
1546
1547                //Do this after the cycle of callGetModule in case the result
1548                //of those calls/init calls changes the registry.
1549                mod = getOwn(registry, moduleName);
1550
1551                if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
1552                    if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
1553                        if (hasPathFallback(moduleName)) {
1554                            return;
1555                        } else {
1556                            return onError(makeError('nodefine',
1557                                             'No define call for ' + moduleName,
1558                                             null,
1559                                             [moduleName]));
1560                        }
1561                    } else {
1562                        //A script that does not call define(), so just simulate
1563                        //the call for it.
1564                        callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
1565                    }
1566                }
1567
1568                checkLoaded();
1569            },
1570
1571            /**
1572             * Converts a module name to a file path. Supports cases where
1573             * moduleName may actually be just an URL.
1574             * Note that it **does not** call normalize on the moduleName,
1575             * it is assumed to have already been normalized. This is an
1576             * internal API, not a public one. Use toUrl for the public API.
1577             */
1578            nameToUrl: function (moduleName, ext, skipExt) {
1579                var paths, syms, i, parentModule, url,
1580                    parentPath, bundleId,
1581                    pkgMain = getOwn(config.pkgs, moduleName);
1582
1583                if (pkgMain) {
1584                    moduleName = pkgMain;
1585                }
1586
1587                bundleId = getOwn(bundlesMap, moduleName);
1588
1589                if (bundleId) {
1590                    return context.nameToUrl(bundleId, ext, skipExt);
1591                }
1592
1593                //If a colon is in the URL, it indicates a protocol is used and it is just
1594                //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
1595                //or ends with .js, then assume the user meant to use an url and not a module id.
1596                //The slash is important for protocol-less URLs as well as full paths.
1597                if (req.jsExtRegExp.test(moduleName)) {
1598                    //Just a plain path, not module name lookup, so just return it.
1599                    //Add extension if it is included. This is a bit wonky, only non-.js things pass
1600                    //an extension, this method probably needs to be reworked.
1601                    url = moduleName + (ext || '');
1602                } else {
1603                    //A module that needs to be converted to a path.
1604                    paths = config.paths;
1605
1606                    syms = moduleName.split('/');
1607                    //For each module name segment, see if there is a path
1608                    //registered for it. Start with most specific name
1609                    //and work up from it.
1610                    for (i = syms.length; i > 0; i -= 1) {
1611                        parentModule = syms.slice(0, i).join('/');
1612
1613                        parentPath = getOwn(paths, parentModule);
1614                        if (parentPath) {
1615                            //If an array, it means there are a few choices,
1616                            //Choose the one that is desired
1617                            if (isArray(parentPath)) {
1618                                parentPath = parentPath[0];
1619                            }
1620                            syms.splice(0, i, parentPath);
1621                            break;
1622                        }
1623                    }
1624
1625                    //Join the path parts together, then figure out if baseUrl is needed.
1626                    url = syms.join('/');
1627                    url += (ext || (/^data\:|\?/.test(url) || skipExt ? '' : '.js'));
1628                    url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
1629                }
1630
1631                return config.urlArgs ? url +
1632                                        ((url.indexOf('?') === -1 ? '?' : '&') +
1633                                         config.urlArgs) : url;
1634            },
1635
1636            //Delegates to req.load. Broken out as a separate function to
1637            //allow overriding in the optimizer.
1638            load: function (id, url) {
1639                req.load(context, id, url);
1640            },
1641
1642            /**
1643             * Executes a module callback function. Broken out as a separate function
1644             * solely to allow the build system to sequence the files in the built
1645             * layer in the right sequence.
1646             *
1647             * @private
1648             */
1649            execCb: function (name, callback, args, exports) {
1650                return callback.apply(exports, args);
1651            },
1652
1653            /**
1654             * callback for script loads, used to check status of loading.
1655             *
1656             * @param {Event} evt the event from the browser for the script
1657             * that was loaded.
1658             */
1659            onScriptLoad: function (evt) {
1660                //Using currentTarget instead of target for Firefox 2.0's sake. Not
1661                //all old browsers will be supported, but this one was easy enough
1662                //to support and still makes sense.
1663                if (evt.type === 'load' ||
1664                        (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
1665                    //Reset interactive script so a script node is not held onto for
1666                    //to long.
1667                    interactiveScript = null;
1668
1669                    //Pull out the name of the module and the context.
1670                    var data = getScriptData(evt);
1671                    context.completeLoad(data.id);
1672                }
1673            },
1674
1675            /**
1676             * Callback for script errors.
1677             */
1678            onScriptError: function (evt) {
1679                var data = getScriptData(evt);
1680                if (!hasPathFallback(data.id)) {
1681                    return onError(makeError('scripterror', 'Script error for: ' + data.id, evt, [data.id]));
1682                }
1683            }
1684        };
1685
1686        context.require = context.makeRequire();
1687        return context;
1688    }
1689
1690    /**
1691     * Main entry point.
1692     *
1693     * If the only argument to require is a string, then the module that
1694     * is represented by that string is fetched for the appropriate context.
1695     *
1696     * If the first argument is an array, then it will be treated as an array
1697     * of dependency string names to fetch. An optional function callback can
1698     * be specified to execute when all of those dependencies are available.
1699     *
1700     * Make a local req variable to help Caja compliance (it assumes things
1701     * on a require that are not standardized), and to give a short
1702     * name for minification/local scope use.
1703     */
1704    req = requirejs = function (deps, callback, errback, optional) {
1705
1706        //Find the right context, use default
1707        var context, config,
1708            contextName = defContextName;
1709
1710        // Determine if have config object in the call.
1711        if (!isArray(deps) && typeof deps !== 'string') {
1712            // deps is a config object
1713            config = deps;
1714            if (isArray(callback)) {
1715                // Adjust args if there are dependencies
1716                deps = callback;
1717                callback = errback;
1718                errback = optional;
1719            } else {
1720                deps = [];
1721            }
1722        }
1723
1724        if (config && config.context) {
1725            contextName = config.context;
1726        }
1727
1728        context = getOwn(contexts, contextName);
1729        if (!context) {
1730            context = contexts[contextName] = req.s.newContext(contextName);
1731        }
1732
1733        if (config) {
1734            context.configure(config);
1735        }
1736
1737        return context.require(deps, callback, errback);
1738    };
1739
1740    /**
1741     * Support require.config() to make it easier to cooperate with other
1742     * AMD loaders on globally agreed names.
1743     */
1744    req.config = function (config) {
1745        return req(config);
1746    };
1747
1748    /**
1749     * Execute something after the current tick
1750     * of the event loop. Override for other envs
1751     * that have a better solution than setTimeout.
1752     * @param  {Function} fn function to execute later.
1753     */
1754    req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
1755        setTimeout(fn, 4);
1756    } : function (fn) { fn(); };
1757
1758    /**
1759     * Export require as a global, but only if it does not already exist.
1760     */
1761    if (!require) {
1762        require = req;
1763    }
1764
1765    req.version = version;
1766
1767    //Used to filter out dependencies that are already paths.
1768    req.jsExtRegExp = /^\/|:|\?|\.js$/;
1769    req.isBrowser = isBrowser;
1770    s = req.s = {
1771        contexts: contexts,
1772        newContext: newContext
1773    };
1774
1775    //Create default context.
1776    req({});
1777
1778    //Exports some context-sensitive methods on global require.
1779    each([
1780        'toUrl',
1781        'undef',
1782        'defined',
1783        'specified'
1784    ], function (prop) {
1785        //Reference from contexts instead of early binding to default context,
1786        //so that during builds, the latest instance of the default context
1787        //with its config gets used.
1788        req[prop] = function () {
1789            var ctx = contexts[defContextName];
1790            return ctx.require[prop].apply(ctx, arguments);
1791        };
1792    });
1793
1794    if (isBrowser) {
1795        head = s.head = document.getElementsByTagName('head')[0];
1796        //If BASE tag is in play, using appendChild is a problem for IE6.
1797        //When that browser dies, this can be removed. Details in this jQuery bug:
1798        //http://dev.jquery.com/ticket/2709
1799        baseElement = document.getElementsByTagName('base')[0];
1800        if (baseElement) {
1801            head = s.head = baseElement.parentNode;
1802        }
1803    }
1804
1805    /**
1806     * Any errors that require explicitly generates will be passed to this
1807     * function. Intercept/override it if you want custom error handling.
1808     * @param {Error} err the error object.
1809     */
1810    req.onError = defaultOnError;
1811
1812    /**
1813     * Creates the node for the load command. Only used in browser envs.
1814     */
1815    req.createNode = function (config, moduleName, url) {
1816        var node = config.xhtml ?
1817                document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
1818                document.createElement('script');
1819        node.type = config.scriptType || 'text/javascript';
1820        node.charset = 'utf-8';
1821        node.async = true;
1822        return node;
1823    };
1824
1825    /**
1826     * Does the request to load a module for the browser case.
1827     * Make this a separate function to allow other environments
1828     * to override it.
1829     *
1830     * @param {Object} context the require context to find state.
1831     * @param {String} moduleName the name of the module.
1832     * @param {Object} url the URL to the module.
1833     */
1834    req.load = function (context, moduleName, url) {
1835        var config = (context && context.config) || {},
1836            node;
1837        if (isBrowser) {
1838            //In the browser so use a script tag
1839            node = req.createNode(config, moduleName, url);
1840
1841            node.setAttribute('data-requirecontext', context.contextName);
1842            node.setAttribute('data-requiremodule', moduleName);
1843
1844            //Set up load listener. Test attachEvent first because IE9 has
1845            //a subtle issue in its addEventListener and script onload firings
1846            //that do not match the behavior of all other browsers with
1847            //addEventListener support, which fire the onload event for a
1848            //script right after the script execution. See:
1849            //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
1850            //UNFORTUNATELY Opera implements attachEvent but does not follow the script
1851            //script execution mode.
1852            if (node.attachEvent &&
1853                    //Check if node.attachEvent is artificially added by custom script or
1854                    //natively supported by browser
1855                    //read https://github.com/jrburke/requirejs/issues/187
1856                    //if we can NOT find [native code] then it must NOT natively supported.
1857                    //in IE8, node.attachEvent does not have toString()
1858                    //Note the test for "[native code" with no closing brace, see:
1859                    //https://github.com/jrburke/requirejs/issues/273
1860                    !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
1861                    !isOpera) {
1862                //Probably IE. IE (at least 6-8) do not fire
1863                //script onload right after executing the script, so
1864                //we cannot tie the anonymous define call to a name.
1865                //However, IE reports the script as being in 'interactive'
1866                //readyState at the time of the define call.
1867                useInteractive = true;
1868
1869                node.attachEvent('onreadystatechange', context.onScriptLoad);
1870                //It would be great to add an error handler here to catch
1871                //404s in IE9+. However, onreadystatechange will fire before
1872                //the error handler, so that does not help. If addEventListener
1873                //is used, then IE will fire error before load, but we cannot
1874                //use that pathway given the connect.microsoft.com issue
1875                //mentioned above about not doing the 'script execute,
1876                //then fire the script load event listener before execute
1877                //next script' that other browsers do.
1878                //Best hope: IE10 fixes the issues,
1879                //and then destroys all installs of IE 6-9.
1880                //node.attachEvent('onerror', context.onScriptError);
1881            } else {
1882                node.addEventListener('load', context.onScriptLoad, false);
1883                node.addEventListener('error', context.onScriptError, false);
1884            }
1885            node.src = url;
1886
1887            //For some cache cases in IE 6-8, the script executes before the end
1888            //of the appendChild execution, so to tie an anonymous define
1889            //call to the module name (which is stored on the node), hold on
1890            //to a reference to this node, but clear after the DOM insertion.
1891            currentlyAddingScript = node;
1892            if (baseElement) {
1893                head.insertBefore(node, baseElement);
1894            } else {
1895                head.appendChild(node);
1896            }
1897            currentlyAddingScript = null;
1898
1899            return node;
1900        } else if (isWebWorker) {
1901            try {
1902                //In a web worker, use importScripts. This is not a very
1903                //efficient use of importScripts, importScripts will block until
1904                //its script is downloaded and evaluated. However, if web workers
1905                //are in play, the expectation that a build has been done so that
1906                //only one script needs to be loaded anyway. This may need to be
1907                //reevaluated if other use cases become common.
1908                importScripts(url);
1909
1910                //Account for anonymous modules
1911                context.completeLoad(moduleName);
1912            } catch (e) {
1913                context.onError(makeError('importscripts',
1914                                'importScripts failed for ' +
1915                                    moduleName + ' at ' + url,
1916                                e,
1917                                [moduleName]));
1918            }
1919        }
1920    };
1921
1922    function getInteractiveScript() {
1923        if (interactiveScript && interactiveScript.readyState === 'interactive') {
1924            return interactiveScript;
1925        }
1926
1927        eachReverse(scripts(), function (script) {
1928            if (script.readyState === 'interactive') {
1929                return (interactiveScript = script);
1930            }
1931        });
1932        return interactiveScript;
1933    }
1934
1935    //Look for a data-main script attribute, which could also adjust the baseUrl.
1936    if (isBrowser && !cfg.skipDataMain) {
1937        //Figure out baseUrl. Get it from the script tag with require.js in it.
1938        eachReverse(scripts(), function (script) {
1939            //Set the 'head' where we can append children by
1940            //using the script's parent.
1941            if (!head) {
1942                head = script.parentNode;
1943            }
1944
1945            //Look for a data-main attribute to set main script for the page
1946            //to load. If it is there, the path to data main becomes the
1947            //baseUrl, if it is not already set.
1948            dataMain = script.getAttribute('data-main');
1949            if (dataMain) {
1950                //Preserve dataMain in case it is a path (i.e. contains '?')
1951                mainScript = dataMain;
1952
1953                //Set final baseUrl if there is not already an explicit one.
1954                if (!cfg.baseUrl) {
1955                    //Pull off the directory of data-main for use as the
1956                    //baseUrl.
1957                    src = mainScript.split('/');
1958                    mainScript = src.pop();
1959                    subPath = src.length ? src.join('/')  + '/' : './';
1960
1961                    cfg.baseUrl = subPath;
1962                }
1963
1964                //Strip off any trailing .js since mainScript is now
1965                //like a module name.
1966                mainScript = mainScript.replace(jsSuffixRegExp, '');
1967
1968                 //If mainScript is still a path, fall back to dataMain
1969                if (req.jsExtRegExp.test(mainScript)) {
1970                    mainScript = dataMain;
1971                }
1972
1973                //Put the data-main script in the files to load.
1974                cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];
1975
1976                return true;
1977            }
1978        });
1979    }
1980
1981    /**
1982     * The function that handles definitions of modules. Differs from
1983     * require() in that a string for the module should be the first argument,
1984     * and the function to execute after dependencies are loaded should
1985     * return a value to define the module corresponding to the first argument's
1986     * name.
1987     */
1988    define = function (name, deps, callback) {
1989        var node, context;
1990
1991        //Allow for anonymous modules
1992        if (typeof name !== 'string') {
1993            //Adjust args appropriately
1994            callback = deps;
1995            deps = name;
1996            name = null;
1997        }
1998
1999        //This module may not have dependencies
2000        if (!isArray(deps)) {
2001            callback = deps;
2002            deps = null;
2003        }
2004