MDL-49046 javascript: Add support for AMD modules and jquery.
[moodle.git] / lib / requirejs / require.js
1 /** vim: et:ts=4:sw=4:sts=4
2  * @license RequireJS 2.1.15 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 */
11 var requirejs, require, define;
12 (function (global) {
13     var req, s, head, baseElement, dataMain, src,
14         interactiveScript, currentlyAddingScript, mainScript, subPath,
15         version = '2.1.15',
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;
41     function isFunction(it) {
42         return ostring.call(it) === '[object Function]';
43     }
45     function isArray(it) {
46         return ostring.call(it) === '[object Array]';
47     }
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     }
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     }
79     function hasProp(obj, prop) {
80         return hasOwn.call(obj, prop);
81     }
83     function getOwn(obj, prop) {
84         return hasProp(obj, prop) && obj[prop];
85     }
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     }
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)) {
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     }
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     }
136     function scripts() {
137         return document.getElementsByTagName('script');
138     }
140     function defaultOnError(err) {
141         throw err;
142     }
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     }
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     }
175     if (typeof define !== 'undefined') {
176         //If a define is already in play via another AMD loader,
177         //do not overwrite.
178         return;
179     }
181     if (typeof requirejs !== 'undefined') {
182         if (isFunction(requirejs)) {
183             //Do not overwrite an existing requirejs instance.
184             return;
185         }
186         cfg = requirejs;
187         requirejs = undefined;
188     }
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     }
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;
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;
236             for (i = 0; i < ary.length; i++) {
237                 part = ary[i];
238                 if (part === '.') {
239                     ary.splice(i, 1);
240                     i -= 1;
241                 } else if (part === '..') {
242                     // If at the start, or previous value is still ..,
243                     // keep them so that when converted to a path it may
244                     // still work when converted to a path, even though
245                     // as an ID it is less than ideal. In larger point
246                     // releases, may be better to just kick out an error.
247                     if (i === 0 || (i == 1 && ary[2] === '..') || ary[i - 1] === '..') {
248                         continue;
249                     } else if (i > 0) {
250                         ary.splice(i - 1, 2);
251                         i -= 2;
252                     }
253                 }
254             }
255         }
257         /**
258          * Given a relative module name, like ./something, normalize it to
259          * a real name that can be mapped to a path.
260          * @param {String} name the relative name
261          * @param {String} baseName a real name that the name arg is relative
262          * to.
263          * @param {Boolean} applyMap apply the map config to the value. Should
264          * only be done if this normalization is for a dependency ID.
265          * @returns {String} normalized name
266          */
267         function normalize(name, baseName, applyMap) {
268             var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
269                 foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
270                 baseParts = (baseName && baseName.split('/')),
271                 map = config.map,
272                 starMap = map && map['*'];
274             //Adjust any relative paths.
275             if (name) {
276                 name = name.split('/');
277                 lastIndex = name.length - 1;
279                 // If wanting node ID compatibility, strip .js from end
280                 // of IDs. Have to do this here, and not in nameToUrl
281                 // because node allows either .js or non .js to map
282                 // to same file.
283                 if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
284                     name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
285                 }
287                 // Starts with a '.' so need the baseName
288                 if (name[0].charAt(0) === '.' && baseParts) {
289                     //Convert baseName to array, and lop off the last part,
290                     //so that . matches that 'directory' and not name of the baseName's
291                     //module. For instance, baseName of 'one/two/three', maps to
292                     //'one/two/three.js', but we want the directory, 'one/two' for
293                     //this normalization.
294                     normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
295                     name = normalizedBaseParts.concat(name);
296                 }
298                 trimDots(name);
299                 name = name.join('/');
300             }
302             //Apply map config if available.
303             if (applyMap && map && (baseParts || starMap)) {
304                 nameParts = name.split('/');
306                 outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
307                     nameSegment = nameParts.slice(0, i).join('/');
309                     if (baseParts) {
310                         //Find the longest baseName segment match in the config.
311                         //So, do joins on the biggest to smallest lengths of baseParts.
312                         for (j = baseParts.length; j > 0; j -= 1) {
313                             mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
315                             //baseName segment has config, find if it has one for
316                             //this name.
317                             if (mapValue) {
318                                 mapValue = getOwn(mapValue, nameSegment);
319                                 if (mapValue) {
320                                     //Match, update name to the new value.
321                                     foundMap = mapValue;
322                                     foundI = i;
323                                     break outerLoop;
324                                 }
325                             }
326                         }
327                     }
329                     //Check for a star map match, but just hold on to it,
330                     //if there is a shorter segment match later in a matching
331                     //config, then favor over this star map.
332                     if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
333                         foundStarMap = getOwn(starMap, nameSegment);
334                         starI = i;
335                     }
336                 }
338                 if (!foundMap && foundStarMap) {
339                     foundMap = foundStarMap;
340                     foundI = starI;
341                 }
343                 if (foundMap) {
344                     nameParts.splice(0, foundI, foundMap);
345                     name = nameParts.join('/');
346                 }
347             }
349             // If the name points to a package's name, use
350             // the package main instead.
351             pkgMain = getOwn(config.pkgs, name);
353             return pkgMain ? pkgMain : name;
354         }
356         function removeScript(name) {
357             if (isBrowser) {
358                 each(scripts(), function (scriptNode) {
359                     if (scriptNode.getAttribute('data-requiremodule') === name &&
360                             scriptNode.getAttribute('data-requirecontext') === context.contextName) {
361                         scriptNode.parentNode.removeChild(scriptNode);
362                         return true;
363                     }
364                 });
365             }
366         }
368         function hasPathFallback(id) {
369             var pathConfig = getOwn(config.paths, id);
370             if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
371                 //Pop off the first array value, since it failed, and
372                 //retry
373                 pathConfig.shift();
374                 context.require.undef(id);
376                 //Custom require that does not do map translation, since
377                 //ID is "absolute", already mapped/resolved.
378                 context.makeRequire(null, {
379                     skipMap: true
380                 })([id]);
382                 return true;
383             }
384         }
386         //Turns a plugin!resource to [plugin, resource]
387         //with the plugin being undefined if the name
388         //did not have a plugin prefix.
389         function splitPrefix(name) {
390             var prefix,
391                 index = name ? name.indexOf('!') : -1;
392             if (index > -1) {
393                 prefix = name.substring(0, index);
394                 name = name.substring(index + 1, name.length);
395             }
396             return [prefix, name];
397         }
399         /**
400          * Creates a module mapping that includes plugin prefix, module
401          * name, and path. If parentModuleMap is provided it will
402          * also normalize the name via require.normalize()
403          *
404          * @param {String} name the module name
405          * @param {String} [parentModuleMap] parent module map
406          * for the module name, used to resolve relative names.
407          * @param {Boolean} isNormalized: is the ID already normalized.
408          * This is true if this call is done for a define() module ID.
409          * @param {Boolean} applyMap: apply the map config to the ID.
410          * Should only be true if this map is for a dependency.
411          *
412          * @returns {Object}
413          */
414         function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
415             var url, pluginModule, suffix, nameParts,
416                 prefix = null,
417                 parentName = parentModuleMap ? parentModuleMap.name : null,
418                 originalName = name,
419                 isDefine = true,
420                 normalizedName = '';
422             //If no name, then it means it is a require call, generate an
423             //internal name.
424             if (!name) {
425                 isDefine = false;
426                 name = '_@r' + (requireCounter += 1);
427             }
429             nameParts = splitPrefix(name);
430             prefix = nameParts[0];
431             name = nameParts[1];
433             if (prefix) {
434                 prefix = normalize(prefix, parentName, applyMap);
435                 pluginModule = getOwn(defined, prefix);
436             }
438             //Account for relative paths if there is a base name.
439             if (name) {
440                 if (prefix) {
441                     if (pluginModule && pluginModule.normalize) {
442                         //Plugin is loaded, use its normalize method.
443                         normalizedName = pluginModule.normalize(name, function (name) {
444                             return normalize(name, parentName, applyMap);
445                         });
446                     } else {
447                         // If nested plugin references, then do not try to
448                         // normalize, as it will not normalize correctly. This
449                         // places a restriction on resourceIds, and the longer
450                         // term solution is not to normalize until plugins are
451                         // loaded and all normalizations to allow for async
452                         // loading of a loader plugin. But for now, fixes the
453                         // common uses. Details in #1131
454                         normalizedName = name.indexOf('!') === -1 ?
455                                          normalize(name, parentName, applyMap) :
456                                          name;
457                     }
458                 } else {
459                     //A regular module.
460                     normalizedName = normalize(name, parentName, applyMap);
462                     //Normalized name may be a plugin ID due to map config
463                     //application in normalize. The map config values must
464                     //already be normalized, so do not need to redo that part.
465                     nameParts = splitPrefix(normalizedName);
466                     prefix = nameParts[0];
467                     normalizedName = nameParts[1];
468                     isNormalized = true;
470                     url = context.nameToUrl(normalizedName);
471                 }
472             }
474             //If the id is a plugin id that cannot be determined if it needs
475             //normalization, stamp it with a unique ID so two matching relative
476             //ids that may conflict can be separate.
477             suffix = prefix && !pluginModule && !isNormalized ?
478                      '_unnormalized' + (unnormalizedCounter += 1) :
479                      '';
481             return {
482                 prefix: prefix,
483                 name: normalizedName,
484                 parentMap: parentModuleMap,
485                 unnormalized: !!suffix,
486                 url: url,
487                 originalName: originalName,
488                 isDefine: isDefine,
489                 id: (prefix ?
490                         prefix + '!' + normalizedName :
491                         normalizedName) + suffix
492             };
493         }
495         function getModule(depMap) {
496             var id = depMap.id,
497                 mod = getOwn(registry, id);
499             if (!mod) {
500                 mod = registry[id] = new context.Module(depMap);
501             }
503             return mod;
504         }
506         function on(depMap, name, fn) {
507             var id = depMap.id,
508                 mod = getOwn(registry, id);
510             if (hasProp(defined, id) &&
511                     (!mod || mod.defineEmitComplete)) {
512                 if (name === 'defined') {
513                     fn(defined[id]);
514                 }
515             } else {
516                 mod = getModule(depMap);
517                 if (mod.error && name === 'error') {
518                     fn(mod.error);
519                 } else {
520                     mod.on(name, fn);
521                 }
522             }
523         }
525         function onError(err, errback) {
526             var ids = err.requireModules,
527                 notified = false;
529             if (errback) {
530                 errback(err);
531             } else {
532                 each(ids, function (id) {
533                     var mod = getOwn(registry, id);
534                     if (mod) {
535                         //Set error on module, so it skips timeout checks.
536                         mod.error = err;
537                         if (mod.events.error) {
538                             notified = true;
539                             mod.emit('error', err);
540                         }
541                     }
542                 });
544                 if (!notified) {
545                     req.onError(err);
546                 }
547             }
548         }
550         /**
551          * Internal method to transfer globalQueue items to this context's
552          * defQueue.
553          */
554         function takeGlobalQueue() {
555             //Push all the globalDefQueue items into the context's defQueue
556             if (globalDefQueue.length) {
557                 //Array splice in the values since the context code has a
558                 //local var ref to defQueue, so cannot just reassign the one
559                 //on context.
560                 apsp.apply(defQueue,
561                            [defQueue.length, 0].concat(globalDefQueue));
562                 globalDefQueue = [];
563             }
564         }
566         handlers = {
567             'require': function (mod) {
568                 if (mod.require) {
569                     return mod.require;
570                 } else {
571                     return (mod.require = context.makeRequire(mod.map));
572                 }
573             },
574             'exports': function (mod) {
575                 mod.usingExports = true;
576                 if (mod.map.isDefine) {
577                     if (mod.exports) {
578                         return (defined[mod.map.id] = mod.exports);
579                     } else {
580                         return (mod.exports = defined[mod.map.id] = {});
581                     }
582                 }
583             },
584             'module': function (mod) {
585                 if (mod.module) {
586                     return mod.module;
587                 } else {
588                     return (mod.module = {
589                         id: mod.map.id,
590                         uri: mod.map.url,
591                         config: function () {
592                             return  getOwn(config.config, mod.map.id) || {};
593                         },
594                         exports: mod.exports || (mod.exports = {})
595                     });
596                 }
597             }
598         };
600         function cleanRegistry(id) {
601             //Clean up machinery used for waiting modules.
602             delete registry[id];
603             delete enabledRegistry[id];
604         }
606         function breakCycle(mod, traced, processed) {
607             var id = mod.map.id;
609             if (mod.error) {
610                 mod.emit('error', mod.error);
611             } else {
612                 traced[id] = true;
613                 each(mod.depMaps, function (depMap, i) {
614                     var depId = depMap.id,
615                         dep = getOwn(registry, depId);
617                     //Only force things that have not completed
618                     //being defined, so still in the registry,
619                     //and only if it has not been matched up
620                     //in the module already.
621                     if (dep && !mod.depMatched[i] && !processed[depId]) {
622                         if (getOwn(traced, depId)) {
623                             mod.defineDep(i, defined[depId]);
624                             mod.check(); //pass false?
625                         } else {
626                             breakCycle(dep, traced, processed);
627                         }
628                     }
629                 });
630                 processed[id] = true;
631             }
632         }
634         function checkLoaded() {
635             var err, usingPathFallback,
636                 waitInterval = config.waitSeconds * 1000,
637                 //It is possible to disable the wait interval by using waitSeconds of 0.
638                 expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
639                 noLoads = [],
640                 reqCalls = [],
641                 stillLoading = false,
642                 needCycleCheck = true;
644             //Do not bother if this call was a result of a cycle break.
645             if (inCheckLoaded) {
646                 return;
647             }
649             inCheckLoaded = true;
651             //Figure out the state of all the modules.
652             eachProp(enabledRegistry, function (mod) {
653                 var map = mod.map,
654                     modId = map.id;
656                 //Skip things that are not enabled or in error state.
657                 if (!mod.enabled) {
658                     return;
659                 }
661                 if (!map.isDefine) {
662                     reqCalls.push(mod);
663                 }
665                 if (!mod.error) {
666                     //If the module should be executed, and it has not
667                     //been inited and time is up, remember it.
668                     if (!mod.inited && expired) {
669                         if (hasPathFallback(modId)) {
670                             usingPathFallback = true;
671                             stillLoading = true;
672                         } else {
673                             noLoads.push(modId);
674                             removeScript(modId);
675                         }
676                     } else if (!mod.inited && mod.fetched && map.isDefine) {
677                         stillLoading = true;
678                         if (!map.prefix) {
679                             //No reason to keep looking for unfinished
680                             //loading. If the only stillLoading is a
681                             //plugin resource though, keep going,
682                             //because it may be that a plugin resource
683                             //is waiting on a non-plugin cycle.
684                             return (needCycleCheck = false);
685                         }
686                     }
687                 }
688             });
690             if (expired && noLoads.length) {
691                 //If wait time expired, throw error of unloaded modules.
692                 err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
693                 err.contextName = context.contextName;
694                 return onError(err);
695             }
697             //Not expired, check for a cycle.
698             if (needCycleCheck) {
699                 each(reqCalls, function (mod) {
700                     breakCycle(mod, {}, {});
701                 });
702             }
704             //If still waiting on loads, and the waiting load is something
705             //other than a plugin resource, or there are still outstanding
706             //scripts, then just try back later.
707             if ((!expired || usingPathFallback) && stillLoading) {
708                 //Something is still waiting to load. Wait for it, but only
709                 //if a timeout is not already in effect.
710                 if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
711                     checkLoadedTimeoutId = setTimeout(function () {
712                         checkLoadedTimeoutId = 0;
713                         checkLoaded();
714                     }, 50);
715                 }
716             }
718             inCheckLoaded = false;
719         }
721         Module = function (map) {
722             this.events = getOwn(undefEvents, map.id) || {};
723             this.map = map;
724             this.shim = getOwn(config.shim, map.id);
725             this.depExports = [];
726             this.depMaps = [];
727             this.depMatched = [];
728             this.pluginMaps = {};
729             this.depCount = 0;
731             /* this.exports this.factory
732                this.depMaps = [],
733                this.enabled, this.fetched
734             */
735         };
737         Module.prototype = {
738             init: function (depMaps, factory, errback, options) {
739                 options = options || {};
741                 //Do not do more inits if already done. Can happen if there
742                 //are multiple define calls for the same module. That is not
743                 //a normal, common case, but it is also not unexpected.
744                 if (this.inited) {
745                     return;
746                 }
748                 this.factory = factory;
750                 if (errback) {
751                     //Register for errors on this module.
752                     this.on('error', errback);
753                 } else if (this.events.error) {
754                     //If no errback already, but there are error listeners
755                     //on this module, set up an errback to pass to the deps.
756                     errback = bind(this, function (err) {
757                         this.emit('error', err);
758                     });
759                 }
761                 //Do a copy of the dependency array, so that
762                 //source inputs are not modified. For example
763                 //"shim" deps are passed in here directly, and
764                 //doing a direct modification of the depMaps array
765                 //would affect that config.
766                 this.depMaps = depMaps && depMaps.slice(0);
768                 this.errback = errback;
770                 //Indicate this module has be initialized
771                 this.inited = true;
773                 this.ignore = options.ignore;
775                 //Could have option to init this module in enabled mode,
776                 //or could have been previously marked as enabled. However,
777                 //the dependencies are not known until init is called. So
778                 //if enabled previously, now trigger dependencies as enabled.
779                 if (options.enabled || this.enabled) {
780                     //Enable this module and dependencies.
781                     //Will call this.check()
782                     this.enable();
783                 } else {
784                     this.check();
785                 }
786             },
788             defineDep: function (i, depExports) {
789                 //Because of cycles, defined callback for a given
790                 //export can be called more than once.
791                 if (!this.depMatched[i]) {
792                     this.depMatched[i] = true;
793                     this.depCount -= 1;
794                     this.depExports[i] = depExports;
795                 }
796             },
798             fetch: function () {
799                 if (this.fetched) {
800                     return;
801                 }
802                 this.fetched = true;
804                 context.startTime = (new Date()).getTime();
806                 var map = this.map;
808                 //If the manager is for a plugin managed resource,
809                 //ask the plugin to load it now.
810                 if (this.shim) {
811                     context.makeRequire(this.map, {
812                         enableBuildCallback: true
813                     })(this.shim.deps || [], bind(this, function () {
814                         return map.prefix ? this.callPlugin() : this.load();
815                     }));
816                 } else {
817                     //Regular dependency.
818                     return map.prefix ? this.callPlugin() : this.load();
819                 }
820             },
822             load: function () {
823                 var url = this.map.url;
825                 //Regular dependency.
826                 if (!urlFetched[url]) {
827                     urlFetched[url] = true;
828                     context.load(this.map.id, url);
829                 }
830             },
832             /**
833              * Checks if the module is ready to define itself, and if so,
834              * define it.
835              */
836             check: function () {
837                 if (!this.enabled || this.enabling) {
838                     return;
839                 }
841                 var err, cjsModule,
842                     id = this.map.id,
843                     depExports = this.depExports,
844                     exports = this.exports,
845                     factory = this.factory;
847                 if (!this.inited) {
848                     this.fetch();
849                 } else if (this.error) {
850                     this.emit('error', this.error);
851                 } else if (!this.defining) {
852                     //The factory could trigger another require call
853                     //that would result in checking this module to
854                     //define itself again. If already in the process
855                     //of doing that, skip this work.
856                     this.defining = true;
858                     if (this.depCount < 1 && !this.defined) {
859                         if (isFunction(factory)) {
860                             //If there is an error listener, favor passing
861                             //to that instead of throwing an error. However,
862                             //only do it for define()'d  modules. require
863                             //errbacks should not be called for failures in
864                             //their callbacks (#699). However if a global
865                             //onError is set, use that.
866                             if ((this.events.error && this.map.isDefine) ||
867                                 req.onError !== defaultOnError) {
868                                 try {
869                                     exports = context.execCb(id, factory, depExports, exports);
870                                 } catch (e) {
871                                     err = e;
872                                 }
873                             } else {
874                                 exports = context.execCb(id, factory, depExports, exports);
875                             }
877                             // Favor return value over exports. If node/cjs in play,
878                             // then will not have a return value anyway. Favor
879                             // module.exports assignment over exports object.
880                             if (this.map.isDefine && exports === undefined) {
881                                 cjsModule = this.module;
882                                 if (cjsModule) {
883                                     exports = cjsModule.exports;
884                                 } else if (this.usingExports) {
885                                     //exports already set the defined value.
886                                     exports = this.exports;
887                                 }
888                             }
890                             if (err) {
891                                 err.requireMap = this.map;
892                                 err.requireModules = this.map.isDefine ? [this.map.id] : null;
893                                 err.requireType = this.map.isDefine ? 'define' : 'require';
894                                 return onError((this.error = err));
895                             }
897                         } else {
898                             //Just a literal value
899                             exports = factory;
900                         }
902                         this.exports = exports;
904                         if (this.map.isDefine && !this.ignore) {
905                             defined[id] = exports;
907                             if (req.onResourceLoad) {
908                                 req.onResourceLoad(context, this.map, this.depMaps);
909                             }
910                         }
912                         //Clean up
913                         cleanRegistry(id);
915                         this.defined = true;
916                     }
918                     //Finished the define stage. Allow calling check again
919                     //to allow define notifications below in the case of a
920                     //cycle.
921                     this.defining = false;
923                     if (this.defined && !this.defineEmitted) {
924                         this.defineEmitted = true;
925                         this.emit('defined', this.exports);
926                         this.defineEmitComplete = true;
927                     }
929                 }
930             },
932             callPlugin: function () {
933                 var map = this.map,
934                     id = map.id,
935                     //Map already normalized the prefix.
936                     pluginMap = makeModuleMap(map.prefix);
938                 //Mark this as a dependency for this plugin, so it
939                 //can be traced for cycles.
940                 this.depMaps.push(pluginMap);
942                 on(pluginMap, 'defined', bind(this, function (plugin) {
943                     var load, normalizedMap, normalizedMod,
944                         bundleId = getOwn(bundlesMap, this.map.id),
945                         name = this.map.name,
946                         parentName = this.map.parentMap ? this.map.parentMap.name : null,
947                         localRequire = context.makeRequire(map.parentMap, {
948                             enableBuildCallback: true
949                         });
951                     //If current map is not normalized, wait for that
952                     //normalized name to load instead of continuing.
953                     if (this.map.unnormalized) {
954                         //Normalize the ID if the plugin allows it.
955                         if (plugin.normalize) {
956                             name = plugin.normalize(name, function (name) {
957                                 return normalize(name, parentName, true);
958                             }) || '';
959                         }
961                         //prefix and name should already be normalized, no need
962                         //for applying map config again either.
963                         normalizedMap = makeModuleMap(map.prefix + '!' + name,
964                                                       this.map.parentMap);
965                         on(normalizedMap,
966                             'defined', bind(this, function (value) {
967                                 this.init([], function () { return value; }, null, {
968                                     enabled: true,
969                                     ignore: true
970                                 });
971                             }));
973                         normalizedMod = getOwn(registry, normalizedMap.id);
974                         if (normalizedMod) {
975                             //Mark this as a dependency for this plugin, so it
976                             //can be traced for cycles.
977                             this.depMaps.push(normalizedMap);
979                             if (this.events.error) {
980                                 normalizedMod.on('error', bind(this, function (err) {
981                                     this.emit('error', err);
982                                 }));
983                             }
984                             normalizedMod.enable();
985                         }
987                         return;
988                     }
990                     //If a paths config, then just load that file instead to
991                     //resolve the plugin, as it is built into that paths layer.
992                     if (bundleId) {
993                         this.map.url = context.nameToUrl(bundleId);
994                         this.load();
995                         return;
996                     }
998                     load = bind(this, function (value) {
999                         this.init([], function () { return value; }, null, {
1000                             enabled: true
1001                         });
1002                     });
1004                     load.error = bind(this, function (err) {
1005                         this.inited = true;
1006                         this.error = err;
1007                         err.requireModules = [id];
1009                         //Remove temp unnormalized modules for this module,
1010                         //since they will never be resolved otherwise now.
1011                         eachProp(registry, function (mod) {
1012                             if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
1013                                 cleanRegistry(mod.map.id);
1014                             }
1015                         });
1017                         onError(err);
1018                     });
1020                     //Allow plugins to load other code without having to know the
1021                     //context or how to 'complete' the load.
1022                     load.fromText = bind(this, function (text, textAlt) {
1023                         /*jslint evil: true */
1024                         var moduleName = map.name,
1025                             moduleMap = makeModuleMap(moduleName),
1026                             hasInteractive = useInteractive;
1028                         //As of 2.1.0, support just passing the text, to reinforce
1029                         //fromText only being called once per resource. Still
1030                         //support old style of passing moduleName but discard
1031                         //that moduleName in favor of the internal ref.
1032                         if (textAlt) {
1033                             text = textAlt;
1034                         }
1036                         //Turn off interactive script matching for IE for any define
1037                         //calls in the text, then turn it back on at the end.
1038                         if (hasInteractive) {
1039                             useInteractive = false;
1040                         }
1042                         //Prime the system by creating a module instance for
1043                         //it.
1044                         getModule(moduleMap);
1046                         //Transfer any config to this other module.
1047                         if (hasProp(config.config, id)) {
1048                             config.config[moduleName] = config.config[id];
1049                         }
1051                         try {
1052                             req.exec(text);
1053                         } catch (e) {
1054                             return onError(makeError('fromtexteval',
1055                                              'fromText eval for ' + id +
1056                                             ' failed: ' + e,
1057                                              e,
1058                                              [id]));
1059                         }
1061                         if (hasInteractive) {
1062                             useInteractive = true;
1063                         }
1065                         //Mark this as a dependency for the plugin
1066                         //resource
1067                         this.depMaps.push(moduleMap);
1069                         //Support anonymous modules.
1070                         context.completeLoad(moduleName);
1072                         //Bind the value of that module to the value for this
1073                         //resource ID.
1074                         localRequire([moduleName], load);
1075                     });
1077                     //Use parentName here since the plugin's name is not reliable,
1078                     //could be some weird string with no path that actually wants to
1079                     //reference the parentName's path.
1080                     plugin.load(map.name, localRequire, load, config);
1081                 }));
1083                 context.enable(pluginMap, this);
1084                 this.pluginMaps[pluginMap.id] = pluginMap;
1085             },
1087             enable: function () {
1088                 enabledRegistry[this.map.id] = this;
1089                 this.enabled = true;
1091                 //Set flag mentioning that the module is enabling,
1092                 //so that immediate calls to the defined callbacks
1093                 //for dependencies do not trigger inadvertent load
1094                 //with the depCount still being zero.
1095                 this.enabling = true;
1097                 //Enable each dependency
1098                 each(this.depMaps, bind(this, function (depMap, i) {
1099                     var id, mod, handler;
1101                     if (typeof depMap === 'string') {
1102                         //Dependency needs to be converted to a depMap
1103                         //and wired up to this module.
1104                         depMap = makeModuleMap(depMap,
1105                                                (this.map.isDefine ? this.map : this.map.parentMap),
1106                                                false,
1107                                                !this.skipMap);
1108                         this.depMaps[i] = depMap;
1110                         handler = getOwn(handlers, depMap.id);
1112                         if (handler) {
1113                             this.depExports[i] = handler(this);
1114                             return;
1115                         }
1117                         this.depCount += 1;
1119                         on(depMap, 'defined', bind(this, function (depExports) {
1120                             this.defineDep(i, depExports);
1121                             this.check();
1122                         }));
1124                         if (this.errback) {
1125                             on(depMap, 'error', bind(this, this.errback));
1126                         }
1127                     }
1129                     id = depMap.id;
1130                     mod = registry[id];
1132                     //Skip special modules like 'require', 'exports', 'module'
1133                     //Also, don't call enable if it is already enabled,
1134                     //important in circular dependency cases.
1135                     if (!hasProp(handlers, id) && mod && !mod.enabled) {
1136                         context.enable(depMap, this);
1137                     }
1138                 }));
1140                 //Enable each plugin that is used in
1141                 //a dependency
1142                 eachProp(this.pluginMaps, bind(this, function (pluginMap) {
1143                     var mod = getOwn(registry, pluginMap.id);
1144                     if (mod && !mod.enabled) {
1145                         context.enable(pluginMap, this);
1146                     }
1147                 }));
1149                 this.enabling = false;
1151                 this.check();
1152             },
1154             on: function (name, cb) {
1155                 var cbs = this.events[name];
1156                 if (!cbs) {
1157                     cbs = this.events[name] = [];
1158                 }
1159                 cbs.push(cb);
1160             },
1162             emit: function (name, evt) {
1163                 each(this.events[name], function (cb) {
1164                     cb(evt);
1165                 });
1166                 if (name === 'error') {
1167                     //Now that the error handler was triggered, remove
1168                     //the listeners, since this broken Module instance
1169                     //can stay around for a while in the registry.
1170                     delete this.events[name];
1171                 }
1172             }
1173         };
1175         function callGetModule(args) {
1176             //Skip modules already defined.
1177             if (!hasProp(defined, args[0])) {
1178                 getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
1179             }
1180         }
1182         function removeListener(node, func, name, ieName) {
1183             //Favor detachEvent because of IE9
1184             //issue, see attachEvent/addEventListener comment elsewhere
1185             //in this file.
1186             if (node.detachEvent && !isOpera) {
1187                 //Probably IE. If not it will throw an error, which will be
1188                 //useful to know.
1189                 if (ieName) {
1190                     node.detachEvent(ieName, func);
1191                 }
1192             } else {
1193                 node.removeEventListener(name, func, false);
1194             }
1195         }
1197         /**
1198          * Given an event from a script node, get the requirejs info from it,
1199          * and then removes the event listeners on the node.
1200          * @param {Event} evt
1201          * @returns {Object}
1202          */
1203         function getScriptData(evt) {
1204             //Using currentTarget instead of target for Firefox 2.0's sake. Not
1205             //all old browsers will be supported, but this one was easy enough
1206             //to support and still makes sense.
1207             var node = evt.currentTarget || evt.srcElement;
1209             //Remove the listeners once here.
1210             removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
1211             removeListener(node, context.onScriptError, 'error');
1213             return {
1214                 node: node,
1215                 id: node && node.getAttribute('data-requiremodule')
1216             };
1217         }
1219         function intakeDefines() {
1220             var args;
1222             //Any defined modules in the global queue, intake them now.
1223             takeGlobalQueue();
1225             //Make sure any remaining defQueue items get properly processed.
1226             while (defQueue.length) {
1227                 args = defQueue.shift();
1228                 if (args[0] === null) {
1229                     return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
1230                 } else {
1231                     //args are id, deps, factory. Should be normalized by the
1232                     //define() function.
1233                     callGetModule(args);
1234                 }
1235             }
1236         }
1238         context = {
1239             config: config,
1240             contextName: contextName,
1241             registry: registry,
1242             defined: defined,
1243             urlFetched: urlFetched,
1244             defQueue: defQueue,
1245             Module: Module,
1246             makeModuleMap: makeModuleMap,
1247             nextTick: req.nextTick,
1248             onError: onError,
1250             /**
1251              * Set a configuration for the context.
1252              * @param {Object} cfg config object to integrate.
1253              */
1254             configure: function (cfg) {
1255                 //Make sure the baseUrl ends in a slash.
1256                 if (cfg.baseUrl) {
1257                     if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
1258                         cfg.baseUrl += '/';
1259                     }
1260                 }
1262                 //Save off the paths since they require special processing,
1263                 //they are additive.
1264                 var shim = config.shim,
1265                     objs = {
1266                         paths: true,
1267                         bundles: true,
1268                         config: true,
1269                         map: true
1270                     };
1272                 eachProp(cfg, function (value, prop) {
1273                     if (objs[prop]) {
1274                         if (!config[prop]) {
1275                             config[prop] = {};
1276                         }
1277                         mixin(config[prop], value, true, true);
1278                     } else {
1279                         config[prop] = value;
1280                     }
1281                 });
1283                 //Reverse map the bundles
1284                 if (cfg.bundles) {
1285                     eachProp(cfg.bundles, function (value, prop) {
1286                         each(value, function (v) {
1287                             if (v !== prop) {
1288                                 bundlesMap[v] = prop;
1289                             }
1290                         });
1291                     });
1292                 }
1294                 //Merge shim
1295                 if (cfg.shim) {
1296                     eachProp(cfg.shim, function (value, id) {
1297                         //Normalize the structure
1298                         if (isArray(value)) {
1299                             value = {
1300                                 deps: value
1301                             };
1302                         }
1303                         if ((value.exports || value.init) && !value.exportsFn) {
1304                             value.exportsFn = context.makeShimExports(value);
1305                         }
1306                         shim[id] = value;
1307                     });
1308                     config.shim = shim;
1309                 }
1311                 //Adjust packages if necessary.
1312                 if (cfg.packages) {
1313                     each(cfg.packages, function (pkgObj) {
1314                         var location, name;
1316                         pkgObj = typeof pkgObj === 'string' ? { name: pkgObj } : pkgObj;
1318                         name = pkgObj.name;
1319                         location = pkgObj.location;
1320                         if (location) {
1321                             config.paths[name] = pkgObj.location;
1322                         }
1324                         //Save pointer to main module ID for pkg name.
1325                         //Remove leading dot in main, so main paths are normalized,
1326                         //and remove any trailing .js, since different package
1327                         //envs have different conventions: some use a module name,
1328                         //some use a file name.
1329                         config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
1330                                      .replace(currDirRegExp, '')
1331                                      .replace(jsSuffixRegExp, '');
1332                     });
1333                 }
1335                 //If there are any "waiting to execute" modules in the registry,
1336                 //update the maps for them, since their info, like URLs to load,
1337                 //may have changed.
1338                 eachProp(registry, function (mod, id) {
1339                     //If module already has init called, since it is too
1340                     //late to modify them, and ignore unnormalized ones
1341                     //since they are transient.
1342                     if (!mod.inited && !mod.map.unnormalized) {
1343                         mod.map = makeModuleMap(id);
1344                     }
1345                 });
1347                 //If a deps array or a config callback is specified, then call
1348                 //require with those args. This is useful when require is defined as a
1349                 //config object before require.js is loaded.
1350                 if (cfg.deps || cfg.callback) {
1351                     context.require(cfg.deps || [], cfg.callback);
1352                 }
1353             },
1355             makeShimExports: function (value) {
1356                 function fn() {
1357                     var ret;
1358                     if (value.init) {
1359                         ret = value.init.apply(global, arguments);
1360                     }
1361                     return ret || (value.exports && getGlobal(value.exports));
1362                 }
1363                 return fn;
1364             },
1366             makeRequire: function (relMap, options) {
1367                 options = options || {};
1369                 function localRequire(deps, callback, errback) {
1370                     var id, map, requireMod;
1372                     if (options.enableBuildCallback && callback && isFunction(callback)) {
1373                         callback.__requireJsBuild = true;
1374                     }
1376                     if (typeof deps === 'string') {
1377                         if (isFunction(callback)) {
1378                             //Invalid call
1379                             return onError(makeError('requireargs', 'Invalid require call'), errback);
1380                         }
1382                         //If require|exports|module are requested, get the
1383                         //value for them from the special handlers. Caveat:
1384                         //this only works while module is being defined.
1385                         if (relMap && hasProp(handlers, deps)) {
1386                             return handlers[deps](registry[relMap.id]);
1387                         }
1389                         //Synchronous access to one module. If require.get is
1390                         //available (as in the Node adapter), prefer that.
1391                         if (req.get) {
1392                             return req.get(context, deps, relMap, localRequire);
1393                         }
1395                         //Normalize module name, if it contains . or ..
1396                         map = makeModuleMap(deps, relMap, false, true);
1397                         id = map.id;
1399                         if (!hasProp(defined, id)) {
1400                             return onError(makeError('notloaded', 'Module name "' +
1401                                         id +
1402                                         '" has not been loaded yet for context: ' +
1403                                         contextName +
1404                                         (relMap ? '' : '. Use require([])')));
1405                         }
1406                         return defined[id];
1407                     }
1409                     //Grab defines waiting in the global queue.
1410                     intakeDefines();
1412                     //Mark all the dependencies as needing to be loaded.
1413                     context.nextTick(function () {
1414                         //Some defines could have been added since the
1415                         //require call, collect them.
1416                         intakeDefines();
1418                         requireMod = getModule(makeModuleMap(null, relMap));
1420                         //Store if map config should be applied to this require
1421                         //call for dependencies.
1422                         requireMod.skipMap = options.skipMap;
1424                         requireMod.init(deps, callback, errback, {
1425                             enabled: true
1426                         });
1428                         checkLoaded();
1429                     });
1431                     return localRequire;
1432                 }
1434                 mixin(localRequire, {
1435                     isBrowser: isBrowser,
1437                     /**
1438                      * Converts a module name + .extension into an URL path.
1439                      * *Requires* the use of a module name. It does not support using
1440                      * plain URLs like nameToUrl.
1441                      */
1442                     toUrl: function (moduleNamePlusExt) {
1443                         var ext,
1444                             index = moduleNamePlusExt.lastIndexOf('.'),
1445                             segment = moduleNamePlusExt.split('/')[0],
1446                             isRelative = segment === '.' || segment === '..';
1448                         //Have a file extension alias, and it is not the
1449                         //dots from a relative path.
1450                         if (index !== -1 && (!isRelative || index > 1)) {
1451                             ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
1452                             moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
1453                         }
1455                         return context.nameToUrl(normalize(moduleNamePlusExt,
1456                                                 relMap && relMap.id, true), ext,  true);
1457                     },
1459                     defined: function (id) {
1460                         return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
1461                     },
1463                     specified: function (id) {
1464                         id = makeModuleMap(id, relMap, false, true).id;
1465                         return hasProp(defined, id) || hasProp(registry, id);
1466                     }
1467                 });
1469                 //Only allow undef on top level require calls
1470                 if (!relMap) {
1471                     localRequire.undef = function (id) {
1472                         //Bind any waiting define() calls to this context,
1473                         //fix for #408
1474                         takeGlobalQueue();
1476                         var map = makeModuleMap(id, relMap, true),
1477                             mod = getOwn(registry, id);
1479                         removeScript(id);
1481                         delete defined[id];
1482                         delete urlFetched[map.url];
1483                         delete undefEvents[id];
1485                         //Clean queued defines too. Go backwards
1486                         //in array so that the splices do not
1487                         //mess up the iteration.
1488                         eachReverse(defQueue, function(args, i) {
1489                             if(args[0] === id) {
1490                                 defQueue.splice(i, 1);
1491                             }
1492                         });
1494                         if (mod) {
1495                             //Hold on to listeners in case the
1496                             //module will be attempted to be reloaded
1497                             //using a different config.
1498                             if (mod.events.defined) {
1499                                 undefEvents[id] = mod.events;
1500                             }
1502                             cleanRegistry(id);
1503                         }
1504                     };
1505                 }
1507                 return localRequire;
1508             },
1510             /**
1511              * Called to enable a module if it is still in the registry
1512              * awaiting enablement. A second arg, parent, the parent module,
1513              * is passed in for context, when this method is overridden by
1514              * the optimizer. Not shown here to keep code compact.
1515              */
1516             enable: function (depMap) {
1517                 var mod = getOwn(registry, depMap.id);
1518                 if (mod) {
1519                     getModule(depMap).enable();
1520                 }
1521             },
1523             /**
1524              * Internal method used by environment adapters to complete a load event.
1525              * A load event could be a script load or just a load pass from a synchronous
1526              * load call.
1527              * @param {String} moduleName the name of the module to potentially complete.
1528              */
1529             completeLoad: function (moduleName) {
1530                 var found, args, mod,
1531                     shim = getOwn(config.shim, moduleName) || {},
1532                     shExports = shim.exports;
1534                 takeGlobalQueue();
1536                 while (defQueue.length) {
1537                     args = defQueue.shift();
1538                     if (args[0] === null) {
1539                         args[0] = moduleName;
1540                         //If already found an anonymous module and bound it
1541                         //to this name, then this is some other anon module
1542                         //waiting for its completeLoad to fire.
1543                         if (found) {
1544                             break;
1545                         }
1546                         found = true;
1547                     } else if (args[0] === moduleName) {
1548                         //Found matching define call for this script!
1549                         found = true;
1550                     }
1552                     callGetModule(args);
1553                 }
1555                 //Do this after the cycle of callGetModule in case the result
1556                 //of those calls/init calls changes the registry.
1557                 mod = getOwn(registry, moduleName);
1559                 if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
1560                     if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
1561                         if (hasPathFallback(moduleName)) {
1562                             return;
1563                         } else {
1564                             return onError(makeError('nodefine',
1565                                              'No define call for ' + moduleName,
1566                                              null,
1567                                              [moduleName]));
1568                         }
1569                     } else {
1570                         //A script that does not call define(), so just simulate
1571                         //the call for it.
1572                         callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
1573                     }
1574                 }
1576                 checkLoaded();
1577             },
1579             /**
1580              * Converts a module name to a file path. Supports cases where
1581              * moduleName may actually be just an URL.
1582              * Note that it **does not** call normalize on the moduleName,
1583              * it is assumed to have already been normalized. This is an
1584              * internal API, not a public one. Use toUrl for the public API.
1585              */
1586             nameToUrl: function (moduleName, ext, skipExt) {
1587                 var paths, syms, i, parentModule, url,
1588                     parentPath, bundleId,
1589                     pkgMain = getOwn(config.pkgs, moduleName);
1591                 if (pkgMain) {
1592                     moduleName = pkgMain;
1593                 }
1595                 bundleId = getOwn(bundlesMap, moduleName);
1597                 if (bundleId) {
1598                     return context.nameToUrl(bundleId, ext, skipExt);
1599                 }
1601                 //If a colon is in the URL, it indicates a protocol is used and it is just
1602                 //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
1603                 //or ends with .js, then assume the user meant to use an url and not a module id.
1604                 //The slash is important for protocol-less URLs as well as full paths.
1605                 if (req.jsExtRegExp.test(moduleName)) {
1606                     //Just a plain path, not module name lookup, so just return it.
1607                     //Add extension if it is included. This is a bit wonky, only non-.js things pass
1608                     //an extension, this method probably needs to be reworked.
1609                     url = moduleName + (ext || '');
1610                 } else {
1611                     //A module that needs to be converted to a path.
1612                     paths = config.paths;
1614                     syms = moduleName.split('/');
1615                     //For each module name segment, see if there is a path
1616                     //registered for it. Start with most specific name
1617                     //and work up from it.
1618                     for (i = syms.length; i > 0; i -= 1) {
1619                         parentModule = syms.slice(0, i).join('/');
1621                         parentPath = getOwn(paths, parentModule);
1622                         if (parentPath) {
1623                             //If an array, it means there are a few choices,
1624                             //Choose the one that is desired
1625                             if (isArray(parentPath)) {
1626                                 parentPath = parentPath[0];
1627                             }
1628                             syms.splice(0, i, parentPath);
1629                             break;
1630                         }
1631                     }
1633                     //Join the path parts together, then figure out if baseUrl is needed.
1634                     url = syms.join('/');
1635                     url += (ext || (/^data\:|\?/.test(url) || skipExt ? '' : '.js'));
1636                     url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
1637                 }
1639                 return config.urlArgs ? url +
1640                                         ((url.indexOf('?') === -1 ? '?' : '&') +
1641                                          config.urlArgs) : url;
1642             },
1644             //Delegates to req.load. Broken out as a separate function to
1645             //allow overriding in the optimizer.
1646             load: function (id, url) {
1647                 req.load(context, id, url);
1648             },
1650             /**
1651              * Executes a module callback function. Broken out as a separate function
1652              * solely to allow the build system to sequence the files in the built
1653              * layer in the right sequence.
1654              *
1655              * @private
1656              */
1657             execCb: function (name, callback, args, exports) {
1658                 return callback.apply(exports, args);
1659             },
1661             /**
1662              * callback for script loads, used to check status of loading.
1663              *
1664              * @param {Event} evt the event from the browser for the script
1665              * that was loaded.
1666              */
1667             onScriptLoad: function (evt) {
1668                 //Using currentTarget instead of target for Firefox 2.0's sake. Not
1669                 //all old browsers will be supported, but this one was easy enough
1670                 //to support and still makes sense.
1671                 if (evt.type === 'load' ||
1672                         (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
1673                     //Reset interactive script so a script node is not held onto for
1674                     //to long.
1675                     interactiveScript = null;
1677                     //Pull out the name of the module and the context.
1678                     var data = getScriptData(evt);
1679                     context.completeLoad(data.id);
1680                 }
1681             },
1683             /**
1684              * Callback for script errors.
1685              */
1686             onScriptError: function (evt) {
1687                 var data = getScriptData(evt);
1688                 if (!hasPathFallback(data.id)) {
1689                     return onError(makeError('scripterror', 'Script error for: ' + data.id, evt, [data.id]));
1690                 }
1691             }
1692         };
1694         context.require = context.makeRequire();
1695         return context;
1696     }
1698     /**
1699      * Main entry point.
1700      *
1701      * If the only argument to require is a string, then the module that
1702      * is represented by that string is fetched for the appropriate context.
1703      *
1704      * If the first argument is an array, then it will be treated as an array
1705      * of dependency string names to fetch. An optional function callback can
1706      * be specified to execute when all of those dependencies are available.
1707      *
1708      * Make a local req variable to help Caja compliance (it assumes things
1709      * on a require that are not standardized), and to give a short
1710      * name for minification/local scope use.
1711      */
1712     req = requirejs = function (deps, callback, errback, optional) {
1714         //Find the right context, use default
1715         var context, config,
1716             contextName = defContextName;
1718         // Determine if have config object in the call.
1719         if (!isArray(deps) && typeof deps !== 'string') {
1720             // deps is a config object
1721             config = deps;
1722             if (isArray(callback)) {
1723                 // Adjust args if there are dependencies
1724                 deps = callback;
1725                 callback = errback;
1726                 errback = optional;
1727             } else {
1728                 deps = [];
1729             }
1730         }
1732         if (config && config.context) {
1733             contextName = config.context;
1734         }
1736         context = getOwn(contexts, contextName);
1737         if (!context) {
1738             context = contexts[contextName] = req.s.newContext(contextName);
1739         }
1741         if (config) {
1742             context.configure(config);
1743         }
1745         return context.require(deps, callback, errback);
1746     };
1748     /**
1749      * Support require.config() to make it easier to cooperate with other
1750      * AMD loaders on globally agreed names.
1751      */
1752     req.config = function (config) {
1753         return req(config);
1754     };
1756     /**
1757      * Execute something after the current tick
1758      * of the event loop. Override for other envs
1759      * that have a better solution than setTimeout.
1760      * @param  {Function} fn function to execute later.
1761      */
1762     req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
1763         setTimeout(fn, 4);
1764     } : function (fn) { fn(); };
1766     /**
1767      * Export require as a global, but only if it does not already exist.
1768      */
1769     if (!require) {
1770         require = req;
1771     }
1773     req.version = version;
1775     //Used to filter out dependencies that are already paths.
1776     req.jsExtRegExp = /^\/|:|\?|\.js$/;
1777     req.isBrowser = isBrowser;
1778     s = req.s = {
1779         contexts: contexts,
1780         newContext: newContext
1781     };
1783     //Create default context.
1784     req({});
1786     //Exports some context-sensitive methods on global require.
1787     each([
1788         'toUrl',
1789         'undef',
1790         'defined',
1791         'specified'
1792     ], function (prop) {
1793         //Reference from contexts instead of early binding to default context,
1794         //so that during builds, the latest instance of the default context
1795         //with its config gets used.
1796         req[prop] = function () {
1797             var ctx = contexts[defContextName];
1798             return ctx.require[prop].apply(ctx, arguments);
1799         };
1800     });
1802     if (isBrowser) {
1803         head = s.head = document.getElementsByTagName('head')[0];
1804         //If BASE tag is in play, using appendChild is a problem for IE6.
1805         //When that browser dies, this can be removed. Details in this jQuery bug:
1806         //http://dev.jquery.com/ticket/2709
1807         baseElement = document.getElementsByTagName('base')[0];
1808         if (baseElement) {
1809             head = s.head = baseElement.parentNode;
1810         }
1811     }
1813     /**
1814      * Any errors that require explicitly generates will be passed to this
1815      * function. Intercept/override it if you want custom error handling.
1816      * @param {Error} err the error object.
1817      */
1818     req.onError = defaultOnError;
1820     /**
1821      * Creates the node for the load command. Only used in browser envs.
1822      */
1823     req.createNode = function (config, moduleName, url) {
1824         var node = config.xhtml ?
1825                 document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
1826                 document.createElement('script');
1827         node.type = config.scriptType || 'text/javascript';
1828         node.charset = 'utf-8';
1829         node.async = true;
1830         return node;
1831     };
1833     /**
1834      * Does the request to load a module for the browser case.
1835      * Make this a separate function to allow other environments
1836      * to override it.
1837      *
1838      * @param {Object} context the require context to find state.
1839      * @param {String} moduleName the name of the module.
1840      * @param {Object} url the URL to the module.
1841      */
1842     req.load = function (context, moduleName, url) {
1843         var config = (context && context.config) || {},
1844             node;
1845         if (isBrowser) {
1846             //In the browser so use a script tag
1847             node = req.createNode(config, moduleName, url);
1849             node.setAttribute('data-requirecontext', context.contextName);
1850             node.setAttribute('data-requiremodule', moduleName);
1852             //Set up load listener. Test attachEvent first because IE9 has
1853             //a subtle issue in its addEventListener and script onload firings
1854             //that do not match the behavior of all other browsers with
1855             //addEventListener support, which fire the onload event for a
1856             //script right after the script execution. See:
1857             //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
1858             //UNFORTUNATELY Opera implements attachEvent but does not follow the script
1859             //script execution mode.
1860             if (node.attachEvent &&
1861                     //Check if node.attachEvent is artificially added by custom script or
1862                     //natively supported by browser
1863                     //read https://github.com/jrburke/requirejs/issues/187
1864                     //if we can NOT find [native code] then it must NOT natively supported.
1865                     //in IE8, node.attachEvent does not have toString()
1866                     //Note the test for "[native code" with no closing brace, see:
1867                     //https://github.com/jrburke/requirejs/issues/273
1868                     !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
1869                     !isOpera) {
1870                 //Probably IE. IE (at least 6-8) do not fire
1871                 //script onload right after executing the script, so
1872                 //we cannot tie the anonymous define call to a name.
1873                 //However, IE reports the script as being in 'interactive'
1874                 //readyState at the time of the define call.
1875                 useInteractive = true;
1877                 node.attachEvent('onreadystatechange', context.onScriptLoad);
1878                 //It would be great to add an error handler here to catch
1879                 //404s in IE9+. However, onreadystatechange will fire before
1880                 //the error handler, so that does not help. If addEventListener
1881                 //is used, then IE will fire error before load, but we cannot
1882                 //use that pathway given the connect.microsoft.com issue
1883                 //mentioned above about not doing the 'script execute,
1884                 //then fire the script load event listener before execute
1885                 //next script' that other browsers do.
1886                 //Best hope: IE10 fixes the issues,
1887                 //and then destroys all installs of IE 6-9.
1888                 //node.attachEvent('onerror', context.onScriptError);
1889             } else {
1890                 node.addEventListener('load', context.onScriptLoad, false);
1891                 node.addEventListener('error', context.onScriptError, false);
1892             }
1893             node.src = url;
1895             //For some cache cases in IE 6-8, the script executes before the end
1896             //of the appendChild execution, so to tie an anonymous define
1897             //call to the module name (which is stored on the node), hold on
1898             //to a reference to this node, but clear after the DOM insertion.
1899             currentlyAddingScript = node;
1900             if (baseElement) {
1901                 head.insertBefore(node, baseElement);
1902             } else {
1903                 head.appendChild(node);
1904             }
1905             currentlyAddingScript = null;
1907             return node;
1908         } else if (isWebWorker) {
1909             try {
1910                 //In a web worker, use importScripts. This is not a very
1911                 //efficient use of importScripts, importScripts will block until
1912                 //its script is downloaded and evaluated. However, if web workers
1913                 //are in play, the expectation that a build has been done so that
1914                 //only one script needs to be loaded anyway. This may need to be
1915                 //reevaluated if other use cases become common.
1916                 importScripts(url);
1918                 //Account for anonymous modules
1919                 context.completeLoad(moduleName);
1920             } catch (e) {
1921                 context.onError(makeError('importscripts',
1922                                 'importScripts failed for ' +
1923                                     moduleName + ' at ' + url,
1924                                 e,
1925                                 [moduleName]));
1926             }
1927         }
1928     };
1930     function getInteractiveScript() {
1931         if (interactiveScript && interactiveScript.readyState === 'interactive') {
1932             return interactiveScript;
1933         }
1935         eachReverse(scripts(), function (script) {
1936             if (script.readyState === 'interactive') {
1937                 return (interactiveScript = script);
1938             }
1939         });
1940         return interactiveScript;
1941     }
1943     //Look for a data-main script attribute, which could also adjust the baseUrl.
1944     if (isBrowser && !cfg.skipDataMain) {
1945         //Figure out baseUrl. Get it from the script tag with require.js in it.
1946         eachReverse(scripts(), function (script) {
1947             //Set the 'head' where we can append children by
1948             //using the script's parent.
1949             if (!head) {
1950                 head = script.parentNode;
1951             }
1953             //Look for a data-main attribute to set main script for the page
1954             //to load. If it is there, the path to data main becomes the
1955             //baseUrl, if it is not already set.
1956             dataMain = script.getAttribute('data-main');
1957             if (dataMain) {
1958                 //Preserve dataMain in case it is a path (i.e. contains '?')
1959                 mainScript = dataMain;
1961                 //Set final baseUrl if there is not already an explicit one.
1962                 if (!cfg.baseUrl) {
1963                     //Pull off the directory of data-main for use as the
1964                     //baseUrl.
1965                     src = mainScript.split('/');
1966                     mainScript = src.pop();
1967                     subPath = src.length ? src.join('/')  + '/' : './';
1969                     cfg.baseUrl = subPath;
1970                 }
1972                 //Strip off any trailing .js since mainScript is now
1973                 //like a module name.
1974                 mainScript = mainScript.replace(jsSuffixRegExp, '');
1976                  //If mainScript is still a path, fall back to dataMain
1977                 if (req.jsExtRegExp.test(mainScript)) {
1978                     mainScript = dataMain;
1979                 }
1981                 //Put the data-main script in the files to load.
1982                 cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];
1984                 return true;
1985             }
1986         });
1987     }
1989     /**
1990      * The function that handles definitions of modules. Differs from
1991      * require() in that a string for the module should be the first argument,
1992      * and the function to execute after dependencies are loaded should
1993      * return a value to define the module corresponding to the first argument's
1994      * name.
1995      */
1996     define = function (name, deps, callback) {
1997         var node, context;
1999         //Allow for anonymous modules
2000         if (typeof name !== 'string') {
2001             //Adjust args appropriately
2002             callback = deps;
2003             deps = name;
2004             name = null;
2005         }
2007         //This module may not have dependencies
2008         if (!isArray(deps)) {
2009             callback = deps;
2010             deps = null;
2011         }
2013         //If no name, and callback is a function, then figure out if it a
2014         //CommonJS thing with dependencies.
2015         if (!deps && isFunction(callback)) {
2016             deps = [];
2017             //Remove comments from the callback string,
2018             //look for require calls, and pull them into the dependencies,
2019             //but only if there are function args.
2020             if (callback.length) {
2021                 callback
2022                     .toString()
2023                     .replace(commentRegExp, '')
2024                     .replace(cjsRequireRegExp, function (match, dep) {
2025                         deps.push(dep);
2026                     });
2028                 //May be a CommonJS thing even without require calls, but still
2029                 //could use exports, and module. Avoid doing exports and module
2030                 //work though if it just needs require.
2031                 //REQUIRES the function to expect the CommonJS variables in the
2032                 //order listed below.
2033                 deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
2034             }
2035         }
2037         //If in IE 6-8 and hit an anonymous define() call, do the interactive
2038         //work.
2039         if (useInteractive) {
2040             node = currentlyAddingScript || getInteractiveScript();
2041             if (node) {
2042                 if (!name) {
2043                     name = node.getAttribute('data-requiremodule');
2044                 }
2045                 context = contexts[node.getAttribute('data-requirecontext')];
2046             }
2047         }
2049         //Always save off evaluating the def call until the script onload handler.
2050         //This allows multiple modules to be in a file without prematurely
2051         //tracing dependencies, and allows for anonymous module support,
2052         //where the module name is not known until the script onload event
2053         //occurs. If no context, use the global queue, and get it processed
2054         //in the onscript load callback.
2055         (context ? context.defQueue : globalDefQueue).push([name, deps, callback]);
2056     };
2058     define.amd = {
2059         jQuery: true
2060     };
2063     /**
2064      * Executes the text. Normally just uses eval, but can be modified
2065      * to use a better, environment-specific call. Only used for transpiling
2066      * loader plugins, not for plain JS modules.
2067      * @param {String} text the text to execute/evaluate.
2068      */
2069     req.exec = function (text) {
2070         /*jslint evil: true */
2071         return eval(text);
2072     };
2074     //Set up with config info.
2075     req(cfg);
2076 }(this));