https://svc.mt.gov/itsd/dpage/Scripts/1.0/dpage/dpage.js.uncompressed.js

170allback
171			callback	  //(function, optional) lambda expression to apply to module values implied by dependencies
172		){
173			return contextRequire(config, dependencies, callback, 0, req);
174		},
175
176		// the loader uses the has.js API to control feature inclusion/exclusion; define then use throughout
177		global = this,
178
179		doc = global.document,
180
181		element = doc && doc.createElement("DiV"),
182
183		has = req.has = function(name){
184			return isFunction(hasCache[name]) ? (hasCache[name] = hasCache[name](global, doc, element)) : hasCache[name];
185		},
186
187		hasCache = has.cache = defaultConfig.hasCache;
188
189	has.add = function(name, test, now, force){
190		(hasCache[name]===undefined || force) && (hasCache[name] = test);
191		return now && has(name);
192	};
193
194	 0 && has.add("host-node", userConfig.has && "host-node" in userConfig.has ?
195		userConfig.has["host-node"] :
196		(typeof process == "object" && process.versions && process.versions.node && process.versions.v8));
197	if( 0 ){
198		// fixup the default config for node.js environment
199		require("./_base/configNode.js").config(defaultConfig);
200		// remember node's require (with respect to baseUrl==dojo's root)
201		defaultConfig.loaderPatch.nodeRequire = require;
202	}
203
204	 0 && has.add("host-rhino", userConfig.has && "host-rhino" in userConfig.has ?
205		userConfig.has["host-rhino"] :
206		(typeof load == "function" && (typeof Packages == "function" || typeof Packages == "object")));
207	if( 0 ){
208		// owing to rhino's lame feature that hides the source of the script, give the user a way to specify the baseUrl...
209		for(var baseUrl = userConfig.baseUrl || ".", arg, rhinoArgs = this.arguments, i = 0; i < rhinoArgs.length;){
210			arg = (rhinoArgs[i++] + "").split("=");
211			if(arg[0] == "baseUrl"){
212				baseUrl = arg[1];
213				break;
214			}
215		}
216		load(baseUrl + "/_base/configRhino.js");
217		rhinoDojoConfig(defaultConfig, baseUrl, rhinoArgs);
218	}
219
220	has.add("host-webworker", ((typeof WorkerGlobalScope !== 'undefined') && (self instanceof WorkerGlobalScope)));
221	if(has("host-webworker")){
222		mix(defaultConfig.hasCache, {
223			"host-browser": 0,
224			"dom": 0,
225			"dojo-dom-ready-api": 0,
226			"dojo-sniff": 0,
227			"dojo-inject-api": 1,
228			"host-webworker": 1
229		});
230
231		defaultConfig.loaderPatch = {
232			injectUrl: function(url, callback){
233				// TODO:
234				//		This is not async, nor can it be in Webworkers.  It could be made better by passing
235				//		the entire require array into importScripts at.  This way the scripts are loaded in
236				//		async mode; even if the callbacks are ran in sync.  It is not a major issue as webworkers
237				//		tend to be long running where initial startup is not a major factor.
238
239				try{
240					importScripts(url);
241					callback();
242				}catch(e){
243					console.info("failed to load resource (" + url + ")");
244					console.error(e);
245				}
246			}
247		};
248	}
249
250	// userConfig has tests override defaultConfig has tests; do this after the environment detection because
251	// the environment detection usually sets some has feature values in the hasCache.
252	for(var p in userConfig.has){
253		has.add(p, userConfig.has[p], 0, 1);
254	}
255
256	//
257	// define the loader data
258	//
259
260	// the loader will use these like symbols if the loader has the traceApi; otherwise
261	// define magic numbers so that modules can be provided as part of defaultConfig
262	var	requested = 1,
263		arrived = 2,
264		nonmodule = 3,
265		executing = 4,
266		executed = 5;
267
268	if( 0 ){
269		// these make debugging nice; but using strings for symbols is a gross rookie error; don't do it for production code
270		requested = "requested";
271		arrived = "arrived";
272		nonmodule = "not-a-module";
273		executing = "executing";
274		executed = "executed";
275	}
276
277	var legacyMode = 0,
278		sync = "sync",
279		xd = "xd",
280		syncExecStack = [],
281		dojoRequirePlugin = 0,
282		checkDojoRequirePlugin = noop,
283		transformToAmd = noop,
284		getXhr;
285	if( 0 ){
286		req.isXdUrl = noop;
287
288		req.initSyncLoader = function(dojoRequirePlugin_, checkDojoRequirePlugin_, transformToAmd_){
289			// the first dojo/_base/loader loaded gets to define these variables; they are designed to work
290			// in the presence of zero to many mapped dojo/_base/loaders
291			if(!dojoRequirePlugin){
292				dojoRequirePlugin = dojoRequirePlugin_;
293				checkDojoRequirePlugin = checkDojoRequirePlugin_;
294				transformToAmd = transformToAmd_;
295			}
296
297			return {
298				sync:sync,
299				requested:requested,
300				arrived:arrived,
301				nonmodule:nonmodule,
302				executing:executing,
303				executed:executed,
304				syncExecStack:syncExecStack,
305				modules:modules,
306				execQ:execQ,
307				getModule:getModule,
308				injectModule:injectModule,
309				setArrived:setArrived,
310				signal:signal,
311				finishExec:finishExec,
312				execModule:execModule,
313				dojoRequirePlugin:dojoRequirePlugin,
314				getLegacyMode:function(){return legacyMode;},
315				guardCheckComplete:guardCheckComplete
316			};
317		};
318
319		if( 1  || has("host-webworker")){
320			// in legacy sync mode, the loader needs a minimal XHR library
321
322			var locationProtocol = location.protocol,
323				locationHost = location.host;
324			req.isXdUrl = function(url){
325				if(/^\./.test(url)){
326					// begins with a dot is always relative to page URL; therefore not xdomain
327					return false;
328				}
329				if(/^\/\//.test(url)){
330					// for v1.6- backcompat, url starting with // indicates xdomain
331					return true;
332				}
333				// get protocol and host
334				// \/+ takes care of the typical file protocol that looks like file:///drive/path/to/file
335				// locationHost is falsy if file protocol => if locationProtocol matches and is "file:", || will return false
336				var match = url.match(/^([^\/\:]+\:)\/+([^\/]+)/);
337				return match && (match[1] != locationProtocol || (locationHost && match[2] != locationHost));
338			};
339
340
341			// note: to get the file:// protocol to work in FF, you must set security.fileuri.strict_origin_policy to false in about:config
342			 1 || has.add("dojo-xhr-factory", 1);
343			has.add("dojo-force-activex-xhr",  1  && !doc.addEventListener && window.location.protocol == "file:");
344			has.add("native-xhr", typeof XMLHttpRequest != "undefined");
345			if(has("native-xhr") && !has("dojo-force-activex-xhr")){
346				getXhr = function(){
347					return new XMLHttpRequest();
348				};
349			}else{
350				// if in the browser an old IE; find an xhr
351				for(var XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'], progid, i = 0; i < 3;){
352					try{
353						progid = XMLHTTP_PROGIDS[i++];
354						if(new ActiveXObject(progid)){
355							// this progid works; therefore, use it from now on
356							break;
357						}
358					}catch(e){
359						// squelch; we're just trying to find a good ActiveX progid
360						// if they all fail, then progid ends up as the last attempt and that will signal the error
361						// the first time the client actually tries to exec an xhr
362					}
363				}
364				getXhr = function(){
365					return new ActiveXObject(progid);
366				};
367			}
368			req.getXhr = getXhr;
369
370			has.add("dojo-gettext-api", 1);
371			req.getText = function(url, async, onLoad){
372				var xhr = getXhr();
373				xhr.open('GET', fixupUrl(url), false);
374				xhr.send(null);
375				if(xhr.status == 200 || (!location.host && !xhr.status)){
376					if(onLoad){
377						onLoad(xhr.responseText, async);
378					}
379				}else{
380					throw makeError("xhrFailed", xhr.status);
381				}
382				return xhr.responseText;
383			};
384		}
385	}else{
386		req.async = 1;
387	}
388
389	//
390	// loader eval
391	//
392	var eval_ =
393		// use the function constructor so our eval is scoped close to (but not in) in the global space with minimal pollution
394		new Function('return eval(arguments[0]);');
395
396	req.eval =
397		function(text, hint){
398			return eval_(text + "\r\n//# sourceURL=" + hint);
399		};
400
401	//
402	// loader micro events API
403	//
404	var listenerQueues = {},
405		error = "error",
406		signal = req.signal = function(type, args){
407			var queue = listenerQueues[type];
408			// notice we run a copy of the queue; this allows listeners to add/remove
409			// other listeners without affecting this particular signal
410			forEach(queue && queue.slice(0), function(listener){
411				listener.apply(null, isArray(args) ? args : [args]);
412			});
413		},
414		on = req.on = function(type, listener){
415			// notice a queue is not created until a client actually connects
416			var queue = listenerQueues[type] || (listenerQueues[type] = []);
417			queue.push(listener);
418			return {
419				remove:function(){
420					for(var i = 0; i<queue.length; i++){
421						if(queue[i]===listener){
422							queue.splice(i, 1);
423							return;
424						}
425					}
426				}
427			};
428		};
429
430	// configuration machinery; with an optimized/built defaultConfig, all configuration machinery can be discarded
431	// lexical variables hold key loader data structures to help with minification; these may be completely,
432	// one-time initialized by defaultConfig for optimized/built versions
433	var
434		aliases
435			// a vector of pairs of [regexs or string, replacement] => (alias, actual)
436			= [],
437
438		paths
439			// CommonJS paths
440			= {},
441
442		pathsMapProg
443			// list of (from-path, to-path, regex, length) derived from paths;
444			// a "program" to apply paths; see computeMapProg
445			= [],
446
447		packs
448			// a map from packageId to package configuration object; see fixupPackageInfo
449			= {},
450
451		map = req.map
452			// AMD map config variable; dojo/_base/kernel needs req.map to figure out the scope map
453			= {},
454
455		mapProgs
456			// vector of quads as described by computeMapProg; map-key is AMD map key, map-value is AMD map value
457			= [],
458
459		modules
460			// A hash:(mid) --> (module-object) the module namespace
461			//
462			// pid: the package identifier to which the module belongs (e.g., "dojo"); "" indicates the system or default package
463			// mid: the fully-resolved (i.e., mappings have been applied) module identifier without the package identifier (e.g., "dojo/io/script")
464			// url: the URL from which the module was retrieved
465			// pack: the package object of the package to which the module belongs
466			// executed: 0 => not executed; executing => in the process of traversing deps and running factory; executed => factory has been executed
467			// deps: the dependency vector for this module (vector of modules objects)
468			// def: the factory for this module
469			// result: the result of the running the factory for this module
470			// injected: (0 | requested | arrived) the status of the module; nonmodule means the resource did not call define
471			// load: plugin load function; applicable only for plugins
472			//
473			// Modules go through several phases in creation:
474			//
475			// 1. Requested: some other module's definition or a require application contained the requested module in
476			//	  its dependency vector or executing code explicitly demands a module via req.require.
477			//
478			// 2. Injected: a script element has been appended to the insert-point element demanding the resource implied by the URL
479			//
480			// 3. Loaded: the resource injected in [2] has been evaluated.
481			//
482			// 4. Defined: the resource contained a define statement that advised the loader about the module. Notice that some
483			//	  resources may just contain a bundle of code and never formally define a module via define
484			//
485			// 5. Evaluated: the module was defined via define and the loader has evaluated the factory and computed a result.
486			= {},
487
488		cacheBust
489			// query string to append to module URLs to bust browser cache
490			= "",
491
492		cache
493			// hash:(mid | url)-->(function | string)
494			//
495			// A cache of resources. The resources arrive via a config.cache object, which is a hash from either mid --> function or
496			// url --> string. The url key is distinguished from the mid key by always containing the prefix "url:". url keys as provided
497			// by config.cache always have a string value that represents the contents of the resource at the given url. mid keys as provided
498			// by configl.cache always have a function value that causes the same code to execute as if the module was script injected.
499			//
500			// Both kinds of key-value pairs are entered into cache via the function consumePendingCache, which may relocate keys as given
501			// by any mappings *iff* the config.cache was received as part of a module resource request.
502			//
503			// Further, for mid keys, the implied url is computed and the value is entered into that key as well. This allows mapped modules
504			// to retrieve cached items that may have arrived consequent to another namespace.
505			//
506			 = {},
507
508		urlKeyPrefix
509			// the prefix to prepend to a URL key in the cache.
510			= "url:",
511
512		pendingCacheInsert
513			// hash:(mid)-->(function)
514			//
515			// Gives a set of cache modules pending entry into cache. When cached modules are published to the loader, they are
516			// entered into pendingCacheInsert; modules are then pressed into cache upon (1) AMD define or (2) upon receiving another
517			// independent set of cached modules. (1) is the usual case, and this case allows normalizing mids given in the pending
518			// cache for the local configuration, possibly relocating modules.
519			 = {},
520
521		dojoSniffConfig
522			// map of configuration variables
523			// give the data-dojo-config as sniffed from the document (if any)
524			= {},
525
526		insertPointSibling
527			// the nodes used to locate where scripts are injected into the document
528			= 0;
529
530	if( 1 ){
531		var consumePendingCacheInsert = function(referenceModule){
532				var p, item, match, now, m;
533				for(p in pendingCacheInsert){
534					item = pendingCacheInsert[p];
535					match = p.match(/^url\:(.+)/);
536					if(match){
537						cache[urlKeyPrefix + toUrl(match[1], referenceModule)] =  item;
538					}else if(p=="*now"){
539						now = item;
540					}else if(p!="*noref"){
541						m = getModuleInfo(p, referenceModule, true);
542						cache[m.mid] = cache[urlKeyPrefix + m.url] = item;
543					}
544				}
545				if(now){
546					now(createRequire(referenceModule));
547				}
548				pendingCacheInsert = {};
549			},
550
551			escapeString = function(s){
552				return s.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, function(c){ return "\\" + c; });
553			},
554
555			computeMapProg = function(map, dest){
556				// This routine takes a map as represented by a JavaScript object and initializes dest, a vector of
557				// quads of (map-key, map-value, refex-for-map-key, length-of-map-key), sorted decreasing by length-
558				// of-map-key. The regex looks for the map-key followed by either "/" or end-of-string at the beginning
559				// of a the search source. Notice the map-value is irrelevant to the algorithm
560				dest.splice(0, dest.length);
561				for(var p in map){
562					dest.push([
563						p,
564						map[p],
565						new RegExp("^" + escapeString(p) + "(\/|$)"),
566						p.length]);
567				}
568				dest.sort(function(lhs, rhs){ return rhs[3] - lhs[3]; });
569				return dest;
570			},
571
572			computeAliases = function(config, dest){
573				forEach(config, function(pair){
574					// take a fixed-up copy...
575					dest.push([isString(pair[0]) ? new RegExp("^" + escapeString(pair[0]) + "$") : pair[0], pair[1]]);
576				});
577			},
578
579
580			fixupPackageInfo = function(packageInfo){
581				// calculate the precise (name, location, main, mappings) for a package
582				var name = packageInfo.name;
583				if(!name){
584					// packageInfo must be a string that gives the name
585					name = packageInfo;
586					packageInfo = {name:name};
587				}
588				packageInfo = mix({main:"main"}, packageInfo);
589				packageInfo.location = packageInfo.location ? packageInfo.location : name;
590
591				// packageMap is deprecated in favor of AMD map
592				if(packageInfo.packageMap){
593					map[name] = packageInfo.packageMap;
594				}
595
596				if(!packageInfo.main.indexOf("./")){
597					packageInfo.main = packageInfo.main.substring(2);
598				}
599
600				// now that we've got a fully-resolved package object, push it into the configuration
601				packs[name] = packageInfo;
602			},
603
604			delayedModuleConfig
605				// module config cannot be consumed until the loader is completely initialized; therefore, all
606				// module config detected during booting is memorized and applied at the end of loader initialization
607				// TODO: this is a bit of a kludge; all config should be moved to end of loader initialization, but
608				// we'll delay this chore and do it with a final loader 1.x cleanup after the 2.x loader prototyping is complete
609				= [],
610
611
612			config = function(config, booting, referenceModule){
613				for(var p in config){
614					if(p=="waitSeconds"){
615						req.waitms = (config[p] || 0) * 1000;
616					}
617					if(p=="cacheBust"){
618						cacheBust = config[p] ? (isString(config[p]) ? config[p] : (new Date()).getTime() + "") : "";
619					}
620					if(p=="baseUrl" || p=="combo"){
621						req[p] = config[p];
622					}
623					if( 0  && p=="async"){
624						// falsy or "sync" => legacy sync loader
625						// "xd" => sync but loading xdomain tree and therefore loading asynchronously (not configurable, set automatically by the loader)
626						// "legacyAsync" => permanently in "xd" by choice
627						// "debugAtAllCosts" => trying to load everything via script injection (not implemented)
628						// otherwise, must be truthy => AMD
629						// legacyMode: sync | legacyAsync | xd | false
630						var mode = config[p];
631						req.legacyMode = legacyMode = (isString(mode) && /sync|legacyAsync/.test(mode) ? mode : (!mode ? sync : false));
632						req.async = !legacyMode;
633					}
634					if(config[p]!==hasCache){
635						// accumulate raw config info for client apps which can use this to pass their own config
636						req.rawConfig[p] = config[p];
637						p!="has" && has.add("config-"+p, config[p], 0, booting);
638					}
639				}
640
641				// make sure baseUrl exists
642				if(!req.baseUrl){
643					req.baseUrl = "./";
644				}
645				// make sure baseUrl ends with a slash
646				if(!/\/$/.test(req.baseUrl)){
647					req.baseUrl += "/";
648				}
649
650				// now do the special work for has, packages, packagePaths, paths, aliases, and cache
651
652				for(p in config.has){
653					has.add(p, config.has[p], 0, booting);
654				}
655
656				// for each package found in any packages config item, augment the packs map owned by the loader
657				forEach(config.packages, fixupPackageInfo);
658
659				// for each packagePath found in any packagePaths config item, augment the packageConfig
660				// packagePaths is deprecated; remove in 2.0
661				for(var baseUrl in config.packagePaths){
662					forEach(config.packagePaths[baseUrl], function(packageInfo){
663						var location = baseUrl + "/" + packageInfo;
664						if(isString(packageInfo)){
665							packageInfo = {name:packageInfo};
666						}
667						packageInfo.location = location;
668						fixupPackageInfo(packageInfo);
669					});
670				}
671
672				// notice that computeMapProg treats the dest as a reference; therefore, if/when that variable
673				// is published (see dojo-publish-privates), the published variable will always hold a valid value.
674
675				// this must come after all package processing since package processing may mutate map
676				computeMapProg(mix(map, config.map), mapProgs);
677				forEach(mapProgs, function(item){
678					item[1] = computeMapProg(item[1], []);
679					if(item[0]=="*"){
680						mapProgs.star = item;
681					}
682				});
683
684				// push in any paths and recompute the internal pathmap
685				computeMapProg(mix(paths, config.paths), pathsMapProg);
686
687				// aliases
688				computeAliases(config.aliases, aliases);
689
690				if(booting){
691					delayedModuleConfig.push({config:config.config});
692				}else{
693					for(p in config.config){
694						var module = getModule(p, referenceModule);
695						module.config = mix(module.config || {}, config.config[p]);
696					}
697				}
698
699				// push in any new cache values
700				if(config.cache){
701					consumePendingCacheInsert();
702					pendingCacheInsert = config.cache;
703					if(config.cache["*noref"]){
704						consumePendingCacheInsert();
705					}
706				}
707
708				signal("config", [config, req.rawConfig]);
709			};
710
711		//
712		// execute the various sniffs; userConfig can override and value
713		//
714
715		if(has("dojo-cdn") ||  1 ){
716			// the sniff regex looks for a src attribute ending in dojo.js, optionally preceded with a path.
717			// match[3] returns the path to dojo.js (if any) without the trailing slash. This is used for the
718			// dojo location on CDN deployments and baseUrl when either/both of these are not provided
719			// explicitly in the config data; this is the 1.6- behavior.
720
721			var scripts = doc.getElementsByTagName("script"),
722				i = 0,
723				script, dojoDir, src, match;
724			while(i < scripts.length){
725				script = scripts[i++];
726				if((src = script.getAttribute("src")) && (match = src.match(/(((.*)\/)|^)dojo\.js(\W|$)/i))){
727					// sniff dojoDir and baseUrl
728					dojoDir = match[3] || "";
729					defaultConfig.baseUrl = defaultConfig.baseUrl || dojoDir;
730
731					// remember an insertPointSibling
732					insertPointSibling = script;
733				}
734
735				// sniff configuration on attribute in script element
736				if((src = (script.getAttribute("data-dojo-config") || script.getAttribute("djConfig")))){
737					dojoSniffConfig = req.eval("({ " + src + " })", "data-dojo-config");
738
739					// remember an insertPointSibling
740					insertPointSibling = script;
741				}
742
743				// sniff requirejs attribute
744				if( 0 ){
745					if((src = script.getAttribute("data-main"))){
746						dojoSniffConfig.deps = dojoSniffConfig.deps || [src];
747					}
748				}
749			}
750		}
751
752		if( 0 ){
753			// pass down doh.testConfig from parent as if it were a data-dojo-config
754			try{
755				if(window.parent != window && window.parent.require){
756					var doh = window.parent.require("doh");
757					doh && mix(dojoSniffConfig, doh.testConfig);
758				}
759			}catch(e){}
760		}
761
762		// configure the loader; let the user override defaults
763		req.rawConfig = {};
764		config(defaultConfig, 1);
765
766		// do this before setting userConfig/sniffConfig to allow userConfig/sniff overrides
767		if(has("dojo-cdn")){
768			packs.dojo.location = dojoDir;
769			if(dojoDir){
770				dojoDir += "/";
771			}
772			packs.dijit.location = dojoDir + "../dijit/";
773			packs.dojox.location = dojoDir + "../dojox/";
774		}
775
776		config(userConfig, 1);
777		config(dojoSniffConfig, 1);
778
779	}else{
780		// no config API, assume defaultConfig has everything the loader needs...for the entire lifetime of the application
781		paths = defaultConfig.paths;
782		pathsMapProg = defaultConfig.pathsMapProg;
783		packs = defaultConfig.packs;
784		aliases = defaultConfig.aliases;
785		mapProgs = defaultConfig.mapProgs;
786		modules = defaultConfig.modules;
787		cache = defaultConfig.cache;
788		cacheBust = defaultConfig.cacheBust;
789
790		// remember the default config for other processes (e.g., dojo/config)
791		req.rawConfig = defaultConfig;
792	}
793
794
795	if( 0 ){
796		req.combo = req.combo || {add:noop};
797		var	comboPending = 0,
798			combosPending = [],
799			comboPendingTimer = null;
800	}
801
802
803	// build the loader machinery iaw configuration, including has feature tests
804	var	injectDependencies = function(module){
805			// checkComplete!=0 holds the idle signal; we're not idle if we're injecting dependencies
806			guardCheckComplete(function(){
807				forEach(module.deps, injectModule);
808				if( 0  && comboPending && !comboPendingTimer){
809					comboPendingTimer = setTimeout(function() {
810						comboPending = 0;
811						comboPendingTimer = null;
812						req.combo.done(function(mids, url) {
813							var onLoadCallback= function(){
814								// defQ is a vector of module definitions 1-to-1, onto mids
815								runDefQ(0, mids);
816								checkComplete();
817							};
818							combosPending.push(mids);
819							injectingModule = mids;
820							req.injectUrl(url, onLoadCallback, mids);
821							injectingModule = 0;
822						}, req);
823					}, 0);
824				}
825			});
826		},
827
828		contextRequire = function(a1, a2, a3, referenceModule, contextRequire){
829			var module, syntheticMid;
830			if(isString(a1)){
831				// signature is (moduleId)
832				module = getModule(a1, referenceModule, true);
833				if(module && module.executed){
834					return module.result;
835				}
836				throw makeError("undefinedModule", a1);
837			}
838			if(!isArray(a1)){
839				// a1 is a configuration
840				config(a1, 0, referenceModule);
841
842				// juggle args; (a2, a3) may be (dependencies, callback)
843				a1 = a2;
844				a2 = a3;
845			}
846			if(isArray(a1)){
847				// signature is (requestList [,callback])
848				if(!a1.length){
849					a2 && a2();
850				}else{
851					syntheticMid = "require*" + uid();
852
853					// resolve the request list with respect to the reference module
854					for(var mid, deps = [], i = 0; i < a1.length;){
855						mid = a1[i++];
856						deps.push(getModule(mid, referenceModule));
857					}
858
859					// construct a synthetic module to control execution of the requestList, and, optionally, callback
860					module = mix(makeModuleInfo("", syntheticMid, 0, ""), {
861						injected: arrived,
862						deps: deps,
863						def: a2 || noop,
864						require: referenceModule ? referenceModule.require : req,
865						gc: 1 //garbage collect
866					});
867					modules[module.mid] = module;
868
869					// checkComplete!=0 holds the idle signal; we're not idle if we're injecting dependencies
870					injectDependencies(module);
871
872					// try to immediately execute
873					// if already traversing a factory tree, then strict causes circular dependency to abort the execution; maybe
874					// it's possible to execute this require later after the current traversal completes and avoid the circular dependency.
875					// ...but *always* insist on immediate in synch mode
876					var strict = checkCompleteGuard && legacyMode!=sync;
877					guardCheckComplete(function(){
878						execModule(module, strict);
879					});
880					if(!module.executed){
881						// some deps weren't on board or circular dependency detected and strict; therefore, push into the execQ
882						execQ.push(module);
883					}
884					checkComplete();
885				}
886			}
887			return contextRequire;
888		},
889
890		createRequire = function(module){
891			if(!module){
892				return req;
893			}
894			var result = module.require;
895			if(!result){
896				result = function(a1, a2, a3){
897					return contextRequire(a1, a2, a3, module, result);
898				};
899				module.require = mix(result, req);
900				result.module = module;
901				result.toUrl = function(name){
902					return toUrl(name, module);
903				};
904				result.toAbsMid = function(mid){
905					return toAbsMid(mid, module);
906				};
907				if( 0 ){
908					result.undef = function(mid){
909						req.undef(mid, module);
910					};
911				}
912				if( 0 ){
913					result.syncLoadNls = function(mid){
914						var nlsModuleInfo = getModuleInfo(mid, module),
915							nlsModule = modules[nlsModuleInfo.mid];
916						if(!nlsModule || !nlsModule.executed){
917							cached = cache[nlsModuleInfo.mid] || cache[urlKeyPrefix + nlsModuleInfo.url];
918							if(cached){
919								evalModuleText(cached);
920								nlsModule = modules[nlsModuleInfo.mid];
921							}
922						}
923						return nlsModule && nlsModule.executed && nlsModule.result;
924					};
925				}
926
927			}
928			return result;
929		},
930
931		execQ =
932			// The list of modules that need to be evaluated.
933			[],
934
935		defQ =
936			// The queue of define arguments sent to loader.
937			[],
938
939		waiting =
940			// The set of modules upon which the loader is waiting for definition to arrive
941			{},
942
943		setRequested = function(module){
944			module.injected = requested;
945			waiting[module.mid] = 1;
946			if(module.url){
947				waiting[module.url] = module.pack || 1;
948			}
949			startTimer();
950		},
951
952		setArrived = function(module){
953			module.injected = arrived;
954			delete waiting[module.mid];
955			if(module.url){
956				delete waiting[module.url];
957			}
958			if(isEmpty(waiting)){
959				clearTimer();
960				 0  && legacyMode==xd && (legacyMode = sync);
961			}
962		},
963
964		execComplete = req.idle =
965			// says the loader has completed (or not) its work
966			function(){
967				return !defQ.length && isEmpty(waiting) && !execQ.length && !checkCompleteGuard;
968			},
969
970		runMapProg = function(targetMid, map){
971			// search for targetMid in map; return the map item if found; falsy otherwise
972			if(map){
973			for(var i = 0; i < map.length; i++){
974				if(map[i][2].test(targetMid)){
975					return map[i];
976				}
977			}
978			}
979			return 0;
980		},
981
982		compactPath = function(path){
983			var result = [],
984				segment, lastSegment;
985			path = path.replace(/\\/g, '/').split('/');
986			while(path.length){
987				segment = path.shift();
988				if(segment==".." && result.length && lastSegment!=".."){
989					result.pop();
990					lastSegment = result[result.length - 1];
991				}else if(segment!="."){
992					result.push(lastSegment= segment);
993				} // else ignore "."
994			}
995			return result.join("/");
996		},
997
998		makeModuleInfo = function(pid, mid, pack, url){
999			if( 0 ){
1000				var xd= req.isXdUrl(url);
1001				return {pid:pid, mid:mid, pack:pack, url:url, executed:0, def:0, isXd:xd, isAmd:!!(xd || (packs[pid] && packs[pid].isAmd))};
1002			}else{
1003				return {pid:pid, mid:mid, pack:pack, url:url, executed:0, def:0};
1004			}
1005		},
1006
1007		getModuleInfo_ = function(mid, referenceModule, packs, modules, baseUrl, mapProgs, pathsMapProg, aliases, alwaysCreate){
1008			// arguments are passed instead of using lexical variables so that this function my be used independent of the loader (e.g., the builder)
1009			// alwaysCreate is useful in this case so that getModuleInfo never returns references to real modules owned by the loader
1010			var pid, pack, midInPackage, mapItem, url, result, isRelative, requestedMid;
1011			requestedMid = mid;
1012			isRelative = /^\./.test(mid);
1013			if(/(^\/)|(\:)|(\.js$)/.test(mid) || (isRelative && !referenceModule)){
1014				// absolute path or protocol of .js filetype, or relative path but no reference module and therefore relative to page
1015				// whatever it is, it's not a module but just a URL of some sort
1016				// note: pid===0 indicates the routine is returning an unmodified mid
1017
1018				return makeModuleInfo(0, mid, 0, mid);
1019			}else{
1020				// relative module ids are relative to the referenceModule; get rid of any dots
1021				mid = compactPath(isRelative ? (referenceModule.mid + "/../" + mid) : mid);
1022				if(/^\./.test(mid)){
1023					throw makeError("irrationalPath", mid);
1024				}
1025				// at this point, mid is an absolute mid
1026
1027				// map the mid
1028				if(referenceModule){
1029					mapItem = runMapProg(referenceModule.mid, mapProgs);
1030				}
1031				mapItem = mapItem || mapProgs.star;
1032				mapItem = mapItem && runMapProg(mid, mapItem[1]);
1033
1034				if(mapItem){
1035					mid = mapItem[1] + mid.substring(mapItem[3]);
1036					}
1037
1038				match = mid.match(/^([^\/]+)(\/(.+))?$/);
1039				pid = match ? match[1] : "";
1040				if((pack = packs[pid])){
1041					mid = pid + "/" + (midInPackage = (match[3] || pack.main));
1042				}else{
1043					pid = "";
1044				}
1045
1046				// search aliases
1047				var candidateLength = 0,
1048					candidate = 0;
1049				forEach(aliases, function(pair){
1050					var match = mid.match(pair[0]);
1051					if(match && match.length>candidateLength){
1052						candidate = isFunction(pair[1]) ? mid.replace(pair[0], pair[1]) : pair[1];
1053					}
1054				});
1055				if(candidate){
1056					return getModuleInfo_(candidate, 0, packs, modules, baseUrl, mapProgs, pathsMapProg, aliases, alwaysCreate);
1057				}
1058
1059				result = modules[mid];
1060				if(result){
1061					return alwaysCreate ? makeModuleInfo(result.pid, result.mid, result.pack, result.url) : modules[mid];
1062				}
1063			}
1064			// get here iff the sought-after module does not yet exist; therefore, we need to compute the URL given the
1065			// fully resolved (i.e., all relative indicators and package mapping resolved) module id
1066
1067			// note: pid!==0 indicates the routine is returning a url that has .js appended unmodified mid
1068			mapItem = runMapProg(mid, pathsMapProg);
1069			if(mapItem){
1070				url = mapItem[1] + mid.substring(mapItem[3]);
1071			}else if(pid){
1072				url = pack.location + "/" + midInPackage;
1073			}else if( 0 ){
1074				url = "../" + mid;
1075			}else{
1076				url = mid;
1077			}
1078			// if result is not absolute, add baseUrl
1079			if(!(/(^\/)|(\:)/.test(url))){
1080				url = baseUrl + url;
1081			}
1082			url += ".js";
1083			return makeModuleInfo(pid, mid, pack, compactPath(url));
1084		},
1085
1086		getModuleInfo = function(mid, referenceModule, fromPendingCache){
1087			return getModuleInfo_(mid, referenceModule, packs, modules, req.baseUrl, fromPendingCache ? [] : mapProgs, fromPendingCache ? [] : pathsMapProg, fromPendingCache ? [] : aliases);
1088		},
1089
1090		resolvePluginResourceId = function(plugin, prid, referenceModule){
1091			return plugin.normalize ? plugin.normalize(prid, function(mid){return toAbsMid(mid, referenceModule);}) : toAbsMid(prid, referenceModule);
1092		},
1093
1094		dynamicPluginUidGenerator = 0,
1095
1096		getModule = function(mid, referenceModule, immediate){
1097			// compute and optionally construct (if necessary) the module implied by the mid with respect to referenceModule
1098			var match, plugin, prid, result;
1099			match = mid.match(/^(.+?)\!(.*)$/);
1100			if(match){
1101				// name was <plugin-module>!<plugin-resource-id>
1102				plugin = getModule(match[1], referenceModule, immediate);
1103
1104				if( 0  && legacyMode == sync && !plugin.executed){
1105					injectModule(plugin);
1106					if(plugin.injected===arrived && !plugin.executed){
1107						guardCheckComplete(function(){
1108							execModule(plugin);
1109						});
1110					}
1111					if(plugin.executed){
1112						promoteModuleToPlugin(plugin);
1113					}else{
1114						// we are in xdomain mode for some reason
1115						execQ.unshift(plugin);
1116					}
1117				}
1118
1119
1120
1121				if(plugin.executed === executed && !plugin.load){
1122					// executed the module not knowing it was a plugin
1123					promoteModuleToPlugin(plugin);
1124				}
1125
1126				// if the plugin has not been loaded, then can't resolve the prid and  must assume this plugin is dynamic until we find out otherwise
1127				if(plugin.load){
1128					prid = resolvePluginResourceId(plugin, match[2], referenceModule);
1129					mid = (plugin.mid + "!" + (plugin.dynamic ? ++dynamicPluginUidGenerator + "!" : "") + prid);
1130				}else{
1131					prid = match[2];
1132					mid = plugin.mid + "!" + (++dynamicPluginUidGenerator) + "!waitingForPlugin";
1133				}
1134				result = {plugin:plugin, mid:mid, req:createRequire(referenceModule), prid:prid};
1135			}else{
1136				result = getModuleInfo(mid, referenceModule);
1137			}
1138			return modules[result.mid] || (!immediate && (modules[result.mid] = result));
1139		},
1140
1141		toAbsMid = req.toAbsMid = function(mid, referenceModule){
1142			return getModuleInfo(mid, referenceModule).mid;
1143		},
1144
1145		toUrl = req.toUrl = function(name, referenceModule){
1146			var moduleInfo = getModuleInfo(name+"/x", referenceModule),
1147				url= moduleInfo.url;
1148			return fixupUrl(moduleInfo.pid===0 ?
1149				// if pid===0, then name had a protocol or absolute path; either way, toUrl is the identify function in such cases
1150				name :
1151				// "/x.js" since getModuleInfo automatically appends ".js" and we appended "/x" to make name look like a module id
1152				url.substring(0, url.length-5)
1153			);
1154		},
1155
1156		nonModuleProps = {
1157			injected: arrived,
1158			executed: executed,
1159			def: nonmodule,
1160			result: nonmodule
1161		},
1162
1163		makeCjs = function(mid){
1164			return modules[mid] = mix({mid:mid}, nonModuleProps);
1165		},
1166
1167		cjsRequireModule = makeCjs("require"),
1168		cjsExportsModule = makeCjs("exports"),
1169		cjsModuleModule = makeCjs("module"),
1170
1171		runFactory = function(module, args){
1172			req.trace("loader-run-factory", [module.mid]);
1173			var factory = module.def,
1174				result;
1175			 0  && syncExecStack.unshift(module);
1176			if( 0 ){
1177				try{
1178					result= isFunction(factory) ? factory.apply(null, args) : factory;
1179				}catch(e){
1180					signal(error, module.result = makeError("factoryThrew", [module, e]));
1181				}
1182			}else{
1183				result= isFunction(factory) ? factory.apply(null, args) : factory;
1184			}
1185			module.result = result===undefined && module.cjs ? module.cjs.exports : result;
1186			 0  && syncExecStack.shift(module);
1187		},
1188
1189		abortExec = {},
1190
1191		defOrder = 0,
1192
1193		promoteModuleToPlugin = function(pluginModule){
1194			var plugin = pluginModule.result;
1195			pluginModule.dynamic = plugin.dynamic;
1196			pluginModule.normalize = plugin.normalize;
1197			pluginModule.load = plugin.load;
1198			return pluginModule;
1199		},
1200
1201		resolvePluginLoadQ = function(plugin){
1202			// plugins is a newly executed module that has a loadQ waiting to run
1203
1204			// step 1: traverse the loadQ and fixup the mid and prid; remember the map from original mid to new mid
1205			// recall the original mid was created before the plugin was on board and therefore it was impossible to
1206			// compute the final mid; accordingly, prid may or may not change, but the mid will definitely change
1207			var map = {};
1208			forEach(plugin.loadQ, function(pseudoPluginResource){
1209				// manufacture and insert the real module in modules
1210				var prid = resolvePluginResourceId(plugin, pseudoPluginResource.prid, pseudoPluginResource.req.module),
1211					mid = plugin.dynamic ? pseudoPluginResource.mid.replace(/waitingForPlugin$/, prid) : (plugin.mid + "!" + prid),
1212					pluginResource = mix(mix({}, pseudoPluginResource), {mid:mid, prid:prid, injected:0});
1213				if(!modules[mid]){
1214					// create a new (the real) plugin resource and inject it normally now that the plugin is on board
1215					injectPlugin(modules[mid] = pluginResource);
1216				} // else this was a duplicate request for the same (plugin, rid) for a nondynamic plugin
1217
1218				// pluginResource is really just a placeholder with the wrong mid (because we couldn't calculate it until the plugin was on board)
1219				// mark is as arrived and delete it from modules; the real module was requested above
1220				map[pseudoPluginResource.mid] = modules[mid];
1221				setArrived(pseudoPluginResource);
1222				delete modules[pseudoPluginResource.mid];
1223			});
1224			plugin.loadQ = 0;
1225
1226			// step2: replace all references to any placeholder modules with real modules
1227			var substituteModules = function(module){
1228				for(var replacement, deps = module.deps || [], i = 0; i<deps.length; i++){
1229					replacement = map[deps[i].mid];
1230					if(replacement){
1231						deps[i] = replacement;
1232					}
1233				}
1234			};
1235			for(var p in modules){
1236				substituteModules(modules[p]);
1237			}
1238			forEach(execQ, substituteModules);
1239		},
1240
1241		finishExec = function(module){
1242			req.trace("loader-finish-exec", [module.mid]);
1243			module.executed = executed;
1244			module.defOrder = defOrder++;
1245			 0  && forEach(module.provides, function(cb){ cb(); });
1246			if(module.loadQ){
1247				// the module was a plugin
1248				promoteModuleToPlugin(module);
1249				resolvePluginLoadQ(module);
1250			}
1251			// remove all occurrences of this module from the execQ
1252			for(i = 0; i < execQ.length;){
1253				if(execQ[i] === module){
1254					execQ.splice(i, 1);
1255				}else{
1256					i++;
1257				}
1258			}
1259			// delete references to synthetic modules
1260			if (/^require\*/.test(module.mid)) {
1261				delete modules[module.mid];
1262			}
1263		},
1264
1265		circleTrace = [],
1266
1267		execModule = function(module, strict){
1268			// run the dependency vector, then run the factory for module
1269			if(module.executed === executing){
1270				req.trace("loader-circular-dependency", [circleTrace.concat(module.mid).join("->")]);
1271				return (!module.def || strict) ? abortExec :  (module.cjs && module.cjs.exports);
1272			}
1273			// at this point the module is either not executed or fully executed
1274
1275
1276			if(!module.executed){
1277				if(!module.def){
1278					return abortExec;
1279				}
1280				var mid = module.mid,
1281					deps = module.deps || [],
1282					arg, argResult,
1283					args = [],
1284					i = 0;
1285
1286				if( 0 ){
1287					circleTrace.push(mid);
1288					req.trace("loader-exec-module", ["exec", circleTrace.length, mid]);
1289				}
1290
1291				// for circular dependencies, assume the first module encountered was executed OK
1292				// modules that circularly depend on a module that has not run its factory will get
1293				// the pre-made cjs.exports===module.result. They can take a reference to this object and/or
1294				// add properties to it. When the module finally runs its factory, the factory can
1295				// read/write/replace this object. Notice that so long as the object isn't replaced, any
1296				// reference taken earlier while walking the deps list is still valid.
1297				module.executed = executing;
1298				while((arg = deps[i++])){
1299					argResult = ((arg === cjsRequireModule) ? createRequire(module) :
1300									((arg === cjsExportsModule) ? module.cjs.exports :
1301										((arg === cjsModuleModule) ? module.cjs :
1302											execModule(arg, strict))));
1303					if(argResult === abortExec){
1304						module.executed = 0;
1305						req.trace("loader-exec-module", ["abort", mid]);
1306						 0  && circleTrace.pop();
1307						return abortExec;
1308					}
1309					args.push(argResult);
1310				}
1311				runFactory(module, args);
1312				finishExec(module);
1313				 0  && circleTrace.pop();
1314			}
1315			// at this point the module is guaranteed fully executed
1316
1317			return module.result;
1318		},
1319
1320
1321		checkCompleteGuard = 0,
1322
1323		guardCheckComplete = function(proc){
1324			try{
1325				checkCompleteGuard++;
1326				proc();
1327			}finally{
1328				checkCompleteGuard--;
1329			}
1330			if(execComplete()){
1331				signal("idle", []);
1332			}
1333		},
1334
1335		checkComplete = function(){
1336			// keep going through the execQ as long as at least one factory is executed
1337			// plugins, recursion, cached modules all make for many execution path possibilities
1338			if(checkCompleteGuard){
1339				return;
1340			}
1341			guardCheckComplete(function(){
1342				checkDojoRequirePlugin();
1343				for(var currentDefOrder, module, i = 0; i < execQ.length;){
1344					currentDefOrder = defOrder;
1345					module = execQ[i];
1346					execModule(module);
1347					if(currentDefOrder!=defOrder){
1348						// defOrder was bumped one or more times indicating something was executed (note, this indicates
1349						// the execQ was modified, maybe a lot (for example a later module causes an earlier module to execute)
1350						checkDojoRequirePlugin();
1351						i = 0;
1352					}else{
1353						// nothing happened; check the next module in the exec queue
1354						i++;
1355					}
1356				}
1357			});
1358		};
1359
1360
1361	if( 0 ){
1362		req.undef = function(moduleId, referenceModule){
1363			// In order to reload a module, it must be undefined (this routine) and then re-requested.
1364			// This is useful for testing frameworks (at least).
1365			var module = getModule(moduleId, referenceModule);
1366			setArrived(module);
1367			mix(module, {def:0, executed:0, injected:0, node:0});
1368		};
1369	}
1370
1371	if( 1 ){
1372		if(has("dojo-loader-eval-hint-url")===undefined){
1373			has.add("dojo-loader-eval-hint-url", 1);
1374		}
1375
1376		var fixupUrl= typeof userConfig.fixupUrl == "function" ? userConfig.fixupUrl : function(url){
1377				url += ""; // make sure url is a Javascript string (some paths may be a Java string)
1378				return url + (cacheBust ? ((/\?/.test(url) ? "&" : "?") + cacheBust) : "");
1379			},
1380
1381			injectPlugin = function(
1382				module
1383			){
1384				// injects the plugin module given by module; may have to inject the plugin itself
1385				var plugin = module.plugin;
1386
1387				if(plugin.executed === executed && !plugin.load){
1388					// executed the module not knowing it was a plugin
1389					promoteModuleToPlugin(plugin);
1390				}
1391
1392				var onLoad = function(def){
1393						module.result = def;
1394						setArrived(module);
1395						finishExec(module);
1396						checkComplete();
1397					};
1398
1399				if(plugin.load){
1400					plugin.load(module.prid, module.req, onLoad);
1401				}else if(plugin.loadQ){
1402					plugin.loadQ.push(module);
1403				}else{
1404					// the unshift instead of push is important: we don't want plugins to execute as
1405					// dependencies of some other module because this may cause circles when the plugin
1406					// loadQ is run; also, generally, we want plugins to run early since they may load
1407					// several other modules and therefore can potentially unblock many modules
1408					plugin.loadQ = [module];
1409					execQ.unshift(plugin);
1410					injectModule(plugin);
1411				}
1412			},
1413
1414			// for IE, injecting a module may result in a recursive execution if the module is in the cache
1415
1416			cached = 0,
1417
1418			injectingModule = 0,
1419
1420			injectingCachedModule = 0,
1421
1422			evalModuleText = function(text, module){
1423				// see def() for the injectingCachedModule bracket; it simply causes a short, safe circuit
1424				if(has("config-stripStrict")){
1425					text = text.replace(/"use strict"/g, '');
1426				}
1427				injectingCachedModule = 1;
1428				if( 0 ){
1429					try{
1430						if(text===cached){
1431							cached.call(null);
1432						}else{
1433							req.eval(text, has("dojo-loader-eval-hint-url") ? module.url : module.mid);
1434						}
1435					}catch(e){
1436						signal(error, makeError("evalModuleThrew", module));
1437					}
1438				}else{
1439					if(text===cached){
1440						cached.call(null);
1441					}else{
1442						req.eval(text, has("dojo-loader-eval-hint-url") ? module.url : module.mid);
1443					}
1444				}
1445				injectingCachedModule = 0;
1446			},
1447
1448			injectModule = function(module){
1449				// Inject the module. In the browser environment, this means appending a script element into
1450				// the document; in other environments, it means loading a file.
1451				//
1452				// If in synchronous mode, then get the module synchronously if it's not xdomainLoading.
1453
1454				var mid = module.mid,
1455					url = module.url;
1456				if(module.executed || module.injected || waiting[mid] || (module.url && ((module.pack && waiting[module.url]===module.pack) || waiting[module.url]==1))){
1457					return;
1458				}
1459				setRequested(module);
1460
1461				if( 0 ){
1462					var viaCombo = 0;
1463					if(module.plugin && module.plugin.isCombo){
1464						// a combo plugin; therefore, must be handled by combo service
1465						// the prid should have already been converted to a URL (if required by the plugin) during
1466						// the normalize process; in any event, there is no way for the loader to know how to
1467						// to the conversion; therefore the third argument is zero
1468						req.combo.add(module.plugin.mid, module.prid, 0, req);
1469						viaCombo = 1;
1470					}else if(!module.plugin){
1471						viaCombo = req.combo.add(0, module.mid, module.url, req);
1472					}
1473					if(viaCombo){
1474						comboPending= 1;
1475						return;
1476					}
1477				}
1478
1479				if(module.plugin){
1480					injectPlugin(module);
1481					return;
1482				} // else a normal module (not a plugin)
1483
1484
1485				var onLoadCallback = function(){
1486					runDefQ(module);
1487					if(module.injected !== arrived){
1488						// the script that contained the module arrived and has been executed yet
1489						// nothing was added to the defQ (so it wasn't an AMD module) and the module
1490						// wasn't marked as arrived by dojo.provide (so it wasn't a v1.6- module);
1491						// therefore, it must not have been a module; adjust state accordingly
1492						if(has("dojo-enforceDefine")){
1493							signal(error, makeError("noDefine", module));
1494							return;
1495						}
1496						setArrived(module);
1497						mix(module, nonModuleProps);
1498						req.trace("loader-define-nonmodule", [module.url]);
1499					}
1500
1501					if( 0  && legacyMode){
1502						// must call checkComplete even in for sync loader because we may be in xdomainLoading mode;
1503						// but, if xd loading, then don't call checkComplete until out of the current sync traversal
1504						// in order to preserve order of execution of the dojo.required modules
1505						!syncExecStack.length && checkComplete();
1506					}else{
1507						checkComplete();
1508					}
1509				};
1510				cached = cache[mid] || cache[urlKeyPrefix + module.url];
1511				if(cached){
1512					req.trace("loader-inject", ["cache", module.mid, url]);
1513					evalModuleText(cached, module);
1514					onLoadCallback();
1515					return;
1516				}
1517				if( 0  && legacyMode){
1518					if(module.isXd){
1519						// switch to async mode temporarily; if current legacyMode!=sync, then is must be one of {legacyAsync, xd, false}
1520						legacyMode==sync && (legacyMode = xd);
1521						// fall through and load via script injection
1522					}else if(module.isAmd && legacyMode!=sync){
1523						// fall through and load via script injection
1524					}else{
1525						// mode may be sync, xd/legacyAsync, or async; module may be AMD or legacy; but module is always located on the same domain
1526						var xhrCallback = function(text){
1527							if(legacyMode==sync){
1528								// the top of syncExecStack gives the current synchronously executing module; the loader needs
1529								// to know this if it has to switch to async loading in the middle of evaluating a legacy module
1530								// this happens when a modules dojo.require's a module that must be loaded async because it's xdomain
1531								// (using unshift/shift because there is no back() methods for Javascript arrays)
1532								syncExecStack.unshift(module);
1533								evalModuleText(text, module);
1534								syncExecStack.shift();
1535
1536								// maybe the module was an AMD module
1537								runDefQ(module);
1538
1539								// legacy modules never get to defineModule() => cjs and injected never set; also evaluation implies executing
1540								if(!module.cjs){
1541									setArrived(module);
1542									finishExec(module);
1543								}
1544
1545								if(module.finish){
1546									// while synchronously evaluating this module, dojo.require was applied referencing a module
1547									// that had to be loaded async; therefore, the loader stopped answering all dojo.require
1548									// requests so they could be answered completely in the correct sequence; module.finish gives
1549									// the list of dojo.requires that must be re-applied once all target modules are available;
1550									// make a synthetic module to execute the dojo.require's in the correct order
1551
1552									// compute a guaranteed-unique mid for the synthetic finish module; remember the finish vector; remove it from the reference module
1553									// TODO: can we just leave the module.finish...what's it hurting?
1554									var finishMid = mid + "*finish",
1555										finish = module.finish;
1556									delete module.finish;
1557
1558									def(finishMid, ["dojo", ("dojo/require!" + finish.join(",")).replace(/\./g, "/")], function(dojo){
1559										forEach(finish, function(mid){ dojo.require(mid); });
1560									});
1561									// unshift, not push, which causes the current traversal to be reattempted from the top
1562									execQ.unshift(getModule(finishMid));
1563								}
1564								onLoadCallback();
1565							}else{
1566								text = transformToAmd(module, text);
1567								if(text){
1568									evalModuleText(text, module);
1569									onLoadCallback();
1570								}else{
1571									// if transformToAmd returned falsy, then the module was already AMD and it can be script-injected
1572									// do so to improve debugability(even though it means another download...which probably won't happen with a good browser cache)
1573									injectingModule = module;
1574									req.injectUrl(fixupUrl(url), onLoadCallback, module);
1575									injectingModule = 0;
1576								}
1577							}
1578						};
1579
1580						req.trace("loader-inject", ["xhr", module.mid, url, legacyMode!=sync]);
1581						if( 0 ){
1582							try{
1583								req.getText(url, legacyMode!=sync, xhrCallback);
1584							}catch(e){
1585								signal(error, makeError("xhrInjectFailed", [module, e]));
1586							}
1587						}else{
1588							req.getText(url, legacyMode!=sync, xhrCallback);
1589						}
1590						return;
1591					}
1592				} // else async mode or fell through in xdomain loading mode; either way, load by script injection
1593				req.trace("loader-inject", ["script", module.mid, url]);
1594				injectingModule = module;
1595				req.injectUrl(fixupUrl(url), onLoadCallback, module);
1596				injectingModule = 0;
1597			},
1598
1599			defineModule = function(module, deps, def){
1600				req.trace("loader-define-module", [module.mid, deps]);
1601
1602				if( 0  && module.plugin && module.plugin.isCombo){
1603					// the module is a plugin resource loaded by the combo service
1604					// note: check for module.plugin should be enough since normal plugin resources should
1605					// not follow this path; module.plugin.isCombo is future-proofing belt and suspenders
1606					module.result = isFunction(def) ? def() : def;
1607					setArrived(module);
1608					finishExec(module);
1609					return module;
1610				}
1611
1612				var mid = module.mid;
1613				if(module.injected === arrived){
1614					signal(error, makeError("multipleDefine", module));
1615					return module;
1616				}
1617				mix(module, {
1618					deps: deps,
1619					def: def,
1620					cjs: {
1621						id: module.mid,
1622						uri: module.url,
1623						exports: (module.result = {}),
1624						setExports: function(exports){
1625							module.cjs.exports = exports;
1626						},
1627						config:function(){
1628							return module.config;
1629						}
1630					}
1631				});
1632
1633				// resolve deps with respect to this module
1634				for(var i = 0; deps[i]; i++){
1635					deps[i] = getModule(deps[i], module);
1636				}
1637
1638				if( 0  && legacyMode && !waiting[mid]){
1639					// the module showed up without being asked for; it was probably in a <script> element
1640					injectDependencies(module);
1641					execQ.push(module);
1642					checkComplete();
1643				}
1644				setArrived(module);
1645
1646				if(!isFunction(def) && !deps.length){
1647					module.result = def;
1648					finishExec(module);
1649				}
1650
1651				return module;
1652			},
1653
1654			runDefQ = function(referenceModule, mids){
1655				// defQ is an array of [id, dependencies, factory]
1656				// mids (if any) is a vector of mids given by a combo service
1657				var definedModules = [],
1658					module, args;
1659				while(defQ.length){
1660					args = defQ.shift();
1661					mids && (args[0]= mids.shift());
1662					// explicit define indicates possible multiple modules in a single file; delay injecting dependencies until defQ fully
1663					// processed since modules earlier in the queue depend on already-arrived modules that are later in the queue
1664					// TODO: what if no args[0] and no referenceModule
1665					module = (args[0] && getModule(args[0])) || referenceModule;
1666					definedModules.push([module, args[1], args[2]]);
1667				}
1668				consumePendingCacheInsert(referenceModule);
1669				forEach(definedModules, function(args){
1670					injectDependencies(defineModule.apply(null, args));
1671				});
1672			};
1673	}
1674
1675	var timerId = 0,
1676		clearTimer = noop,
1677		startTimer = noop;
1678	if( 0 ){
1679		// Timer machinery that monitors how long the loader is waiting and signals an error when the timer runs out.
1680		clearTimer = function(){
1681			timerId && clearTimeout(timerId);
1682			timerId = 0;
1683		};
1684
1685		startTimer = function(){
1686			clearTimer();
1687			if(req.waitms){
1688				timerId = global.setTimeout(function(){
1689					clearTimer();
1690					signal(error, makeError("timeout", waiting));
1691				}, req.waitms);
1692			}
1693		};
1694	}
1695
1696	if ( 1 ) {
1697		// Test for IE's different way of signaling when scripts finish loading.  Note that according to
1698		// http://bugs.dojotoolkit.org/ticket/15096#comment:14, IE9 also needs to follow the
1699		// IE specific code path even though it has an addEventListener() method.
1700		// Unknown if special path needed on IE10+, which also has a document.attachEvent() method.
1701		// Should evaluate to false for Opera and Windows 8 apps, even though they document.attachEvent()
1702		//  is defined in both those environments.
1703		has.add("ie-event-behavior", doc.attachEvent && typeof Windows === "undefined" &&
1704			(typeof opera === "undefined" || opera.toString() != "[object Opera]"));
1705	}
1706
1707	if( 1  && ( 1  ||  1 )){
1708		var domOn = function(node, eventName, ieEventName, handler){
1709				// Add an event listener to a DOM node using the API appropriate for the current browser;
1710				// return a function that will disconnect the listener.
1711				if(!has("ie-event-behavior")){
1712					node.addEventListener(eventName, handler, false);
1713					return function(){
1714						node.removeEventListener(eventName, handler, false);
1715					};
1716				}else{
1717					node.attachEvent(ieEventName, handler);
1718					return function(){
1719						node.detachEvent(ieEventName, handler);
1720					};
1721				}
1722			},
1723			windowOnLoadListener = domOn(window, "load", "onload", function(){
1724				req.pageLoaded = 1;
1725				doc.readyState!="complete" && (doc.readyState = "complete");
1726				windowOnLoadListener();
1727			});
1728
1729		if( 1 ){
1730			// if the loader is on the page, there must be at least one script element
1731			// getting its parent and then doing insertBefore solves the "Operation Aborted"
1732			// error in IE from appending to a node that isn't properly closed; see
1733			// dojo/tests/_base/loader/requirejs/simple-badbase.html for an example
1734			// don't use scripts with type dojo/... since these may be removed; see #15809
1735			// prefer to use the insertPoint computed during the config sniff in case a script is removed; see #16958
1736			var scripts = doc.getElementsByTagName("script"),
1737				i = 0,
1738				script;
1739			while(!insertPointSibling){
1740				if(!/^dojo/.test((script = scripts[i++]) && script.type)){
1741					insertPointSibling= script;
1742				}
1743			}
1744
1745			req.injectUrl = function(url, callback, owner){
1746				// insert a script element to the insert-point element with src=url;
1747				// apply callback upon detecting the script has loaded.
1748
1749				var node = owner.node = doc.createElement("script"),
1750					onLoad = function(e){
1751						e = e || window.event;
1752						var node = e.target || e.srcElement;
1753						if(e.type === "load" || /complete|loaded/.test(node.readyState)){
1754							loadDisconnector();
1755							errorDisconnector();
1756							callback && callback();
1757						}
1758					},
1759					loadDisconnector = domOn(node, "load", "onreadystatechange", onLoad),
1760					errorDisconnector = domOn(node, "error", "onerror", function(e){
1761						loadDisconnector();
1762						errorDisconnector();
1763						signal(error, makeError("scriptError", [url, e]));
1764					});
1765
1766				node.type = "text/javascript";
1767				node.charset = "utf-8";
1768				node.src = url;
1769				insertPointSibling.parentNode.insertBefore(node, insertPointSibling);
1770				return node;
1771			};
1772		}
1773	}
1774
1775	if( 0 ){
1776		req.log = function(){
1777			try{
1778				for(var i = 0; i < arguments.length; i++){
1779					console.log(arguments[i]);
1780				}
1781			}catch(e){}
1782		};
1783	}else{
1784		req.log = noop;
1785	}
1786
1787	if( 0 ){
1788		var trace = req.trace = function(
1789			group,	// the trace group to which this application belongs
1790			args	// the contents of the trace
1791		){
1792			///
1793			// Tracing interface by group.
1794			//
1795			// Sends the contents of args to the console iff (req.trace.on && req.trace[group])
1796
1797			if(trace.on && trace.group[group]){
1798				signal("trace", [group, args]);
1799				for(var arg, dump = [], text= "trace:" + group + (args.length ? (":" + args[0]) : ""), i= 1; i<args.length;){
1800					arg = args[i++];
1801					if(isString(arg)){
1802						text += ", " + arg;
1803					}else{
1804						dump.push(arg);
1805					}
1806				}
1807				req.log(text);
1808				dump.length && dump.push(".");
1809				req.log.apply(req, dump);
1810			}
1811		};
1812		mix(trace, {
1813			on:1,
1814			group:{},
1815			set:function(group, value){
1816				if(isString(group)){
1817					trace.group[group]= value;
1818				}else{
1819					mix(trace.group, group);
1820				}
1821			}
1822		});
1823		trace.set(mix(mix(mix({}, defaultConfig.trace), userConfig.trace), dojoSniffConfig.trace));
1824		on("config", function(config){
1825			config.trace && trace.set(config.trace);
1826		});
1827	}else{
1828		req.trace = noop;
1829	}
1830
1831	var def = function(
1832		mid,		  //(commonjs.moduleId, optional)
1833		dependencies, //(array of commonjs.moduleId, optional) list of modules to be loaded before running factory
1834		factory		  //(any)
1835	){
1836		///
1837		// Advises the loader of a module factory. //Implements http://wiki.commonjs.org/wiki/Modules/AsynchronousDefinition.
1838		///
1839		//note
1840		// CommonJS factory scan courtesy of http://requirejs.org
1841
1842		var arity = arguments.length,
1843			defaultDeps = ["require", "exports", "module"],
1844			// the predominate signature...
1845			args = [0, mid, dependencies];
1846		if(arity==1){
1847			args = [0, (isFunction(mid) ? defaultDeps : []), mid];
1848		}else if(arity==2 && isString(mid)){
1849			args = [mid, (isFunction(dependencies) ? defaultDeps : []), dependencies];
1850		}else if(arity==3){
1851			args = [mid, dependencies, factory];
1852		}
1853
1854		if( 0  && args[1]===defaultDeps){
1855			args[2].toString()
1856				.replace(/(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg, "")
1857				.replace(/require\(["']([\w\!\-_\.\/]+)["']\)/g, function(match, dep){
1858				args[1].push(dep);
1859			});
1860		}
1861
1862		req.trace("loader-define", args.slice(0, 2));
1863		var targetModule = args[0] && getModule(args[0]),
1864			module;
1865		if(targetModule && !waiting[targetModule.mid]){
1866			// given a mid that hasn't been requested; therefore, defined through means other than injecting
1867			// consequent to a require() or define() application; examples include defining modules on-the-fly
1868			// due to some code path or including a module in a script element. In any case,
1869			// there is no callback waiting to finish processing and nothing to trigger the defQ and the
1870			// dependencies are never requested; therefore, do it here.
1871			injectDependencies(defineModule(targetModule, args[1], args[2]));
1872		}else if(!has("ie-event-behavior") || ! 1  || injectingCachedModule){
1873			// not IE path: anonymous module and therefore must have been injected; therefore, onLoad will fire immediately
1874			// after script finishes being evaluated and the defQ can be run from that callback to detect the module id
1875			defQ.push(args);
1876		}else{
1877			// IE path: possibly anonymous module and therefore injected; therefore, cannot depend on 1-to-1,
1878			// in-order exec of onLoad with script eval (since it's IE) and must manually detect here
1879			targetModule = targetModule || injectingModule;
1880			if(!targetModule){
1881				for(mid in waiting){
1882					module = modules[mid];
1883					if(module && module.node && module.node.readyState === 'interactive'){
1884						targetModule = module;
1885						break;
1886					}
1887				}
1888				if( 0  && !targetModule){
1889					for(var i = 0; i<combosPending.length; i++){
1890						targetModule = combosPending[i];
1891						if(targetModule.node && targetModule.node.readyState === 'interactive'){
1892							break;
1893						}
1894						targetModule= 0;
1895					}
1896				}
1897			}
1898			if( 0  && isArray(targetModule)){
1899				injectDependencies(defineModule(getModule(targetModule.shift()), args[1], args[2]));
1900				if(!targetModule.length){
1901					combosPending.splice(i, 1);
1902				}
1903			}else if(targetModule){
1904				consumePendingCacheInsert(targetModule);

2538		has.add("device-width", screen.availWidth || innerWidth);
2539
2540		// Tests for DOMNode.attributes[] behavior:
2541		//	 - dom-attributes-explicit - attributes[] only lists explicitly user specified attributes
2542		//	 - dom-attributes-specified-flag (IE8) - need to check attr.specified flag to skip attributes user didn't specify
2543		//	 - Otherwise, in IE6-7. attributes[] will list hundreds of values, so need to do outerHTML to get attrs instead.
2544		var form = document.createElement("form");
2545		has.add("dom-attributes-explicit", form.attributes.length == 0); // W3C
2546		has.add("dom-attributes-specified-flag", form.attributes.length > 0 && form.attributes.length < 40);	// IE8
2547	}
2548
2549	has.clearElement = function(element){
2550		// summary:
2551		//	 Deletes the contents of the element passed to test functions.
2552		element.innerHTML= "";
2553		return element;
2554	};
2555
2556	has.normalize = function(id, toAbsMid){
2557		// summary:
2558		//	 Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s).
2559		//
2560		// toAbsMid: Function
2561		//	 Resolves a relative module id into an absolute module id
2562		var
2563			tokens = id.match(/[\?:]|[^:\?]*/g), i = 0,
2564			get = function(skip){
2565				var term = tokens[i++];
2566				if(term == ":"){
2567					// empty string module name, resolves to 0
2568					return 0;
2569				}else{
2570					// postfixed with a ? means it is a feature to branch on, the term is the name of the feature
2571					if(tokens[i++] == "?"){
2572						if(!skip && has(term)){
2573							// matched the feature, get the first value from the options
2574							return get();
2575						}else{
2576							// did not match, get the second value, passing over the first
2577							get(true);
2578							return get(skip);
2579						}
2580					}
2581					// a module
2582					return term || 0;
2583				}
2584			};
2585		id = get();
2586		return id && toAbsMid(id);
2587	};
2588
2589	has.load = function(id, parentRequire, loaded){
2590		// summary:
2591		//		Conditional loading of AMD modules based on a has feature test value.
2592		// id: String
2593		//		Gives the resolved module id to load.
2594		// parentRequire: Function
2595		//		The loader require function with respect to the module that contained the plugin resource in it's
2596		//		dependency list.
2597		// loaded: Function
2598		//	 Callback to loader that consumes result of plugin demand.
2599
2600		if(id){
2601			parentRequire([id], loaded);
2602		}else{
2603			loaded();
2604		}
2605	};
2606
2607	return has;
2608});
2609
2610},
2611'dojo/_base/config':function(){
2612define(["../has", "require"], function(has, require){
2613	// module:
2614	//		dojo/_base/config
2615
2616/*=====
2617return {
2618	// summary:
2619	//		This module defines the user configuration during bootstrap.
2620	// description:
2621	//		By defining user configuration as a module value, an entire configuration can be specified in a build,
2622	//		thereby eliminating the need for sniffing and or explicitly setting in the global variable dojoConfig.
2623	//		Also, when multiple instances of dojo exist in a single application, each will necessarily be located
2624	//		at an unique absolute module identifier as given by the package configuration. Implementing configuration
2625	//		as a module allows for specifying unique, per-instance configurations.
2626	// example:
2627	//		Create a second instance of dojo with a different, instance-unique configuration (assume the loader and
2628	//		dojo.js are already loaded).
2629	//		|	// specify a configuration that creates a new instance of dojo at the absolute module identifier "myDojo"
2630	//		|	require({
2631	//		|		packages:[{
2632	//		|			name:"myDojo",
2633	//		|			location:".", //assume baseUrl points to dojo.js
2634	//		|		}]
2635	//		|	});
2636	//		|
2637	//		|	// specify a configuration for the myDojo instance
2638	//		|	define("myDojo/config", {
2639	//		|		// normal configuration variables go here, e.g.,
2640	//		|		locale:"fr-ca"
2641	//		|	});
2642	//		|
2643	//		|	// load and use the new instance of dojo
2644	//		|	require(["myDojo"], function(dojo){
2645	//		|		// dojo is the new instance of dojo
2646	//		|		// use as required
2647	//		|	});
2648
2649	// isDebug: Boolean
2650	//		Defaults to `false`. If set to `true`, ensures that Dojo provides
2651	//		extended debugging feedback via Firebug. If Firebug is not available
2652	//		on your platform, setting `isDebug` to `true` will force Dojo to
2653	//		pull in (and display) the version of Firebug Lite which is
2654	//		integrated into the Dojo distribution, thereby always providing a
2655	//		debugging/logging console when `isDebug` is enabled. Note that
2656	//		Firebug's `console.*` methods are ALWAYS defined by Dojo. If
2657	//		`isDebug` is false and you are on a platform without Firebug, these
2658	//		methods will be defined as no-ops.
2659	isDebug: false,
2660
2661	// locale: String
2662	//		The locale to assume for loading localized resources in this page,
2663	//		specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
2664	//		Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`.