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