dojo-rails 0.9.8 → 0.9.9

data/vendor/assets/javascripts/dojo/_base/loader.js

@@ -0,0 +1,258 @@
+/*
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
+	Available via Academic Free License >= 2.1 OR the modified BSD license.
+	see: http://dojotoolkit.org/license for details
+*/
+
+//>>built
+define("dojo/_base/loader",["./kernel","../has","require","module","./json","./lang","./array"],function(_1,_2,_3,_4,_5,_6,_7){
+if(!1){
+console.error("cannot load the Dojo v1.x loader with a foreign loader");
+return 0;
+}
+var _8=function(id){
+return {src:_4.id,id:id};
+},_9=function(_a){
+return _a.replace(/\./g,"/");
+},_b=/\/\/>>built/,_c=[],_d=[],_e=function(_f,_10,_11){
+_c.push(_11);
+_7.forEach(_f.split(","),function(mid){
+var _12=_13(mid,_10.module);
+_d.push(_12);
+_14(_12);
+});
+_15();
+},_16,_17=function(m){
+_16[m.mid]=1;
+for(var t,_18,_19=m.deps||[],i=0;i<_19.length;i++){
+_18=_19[i];
+if(!(t=_16[_18.mid])){
+if(t===0||!_17(_18)){
+_16[m.mid]=0;
+return false;
+}
+}
+}
+return true;
+},_15=function(){
+var _1a,mid;
+_16={};
+for(mid in _1b){
+_1a=_1b[mid];
+if(_1a.executed||_1a.noReqPluginCheck){
+_16[mid]=1;
+}else{
+if(_1a.noReqPluginCheck!==0){
+_1a.noReqPluginCheck=/loadInit\!/.test(mid)||/require\!/.test(mid)?1:0;
+}
+if(_1a.noReqPluginCheck){
+_16[mid]=1;
+}else{
+if(_1a.injected!==_1c){
+_16[mid]=0;
+}
+}
+}
+}
+for(var t,i=0,end=_d.length;i<end;i++){
+_1a=_d[i];
+if(!(t=_16[_1a.mid])){
+if(t===0||!_17(_1a)){
+return;
+}
+}
+}
+_1d.holdIdle();
+var _1e=_c;
+_c=[];
+_7.forEach(_1e,function(cb){
+cb(1);
+});
+_1d.releaseIdle();
+},_1f=function(mid,_20,_21){
+_20([mid],function(_22){
+_20(_22.names,function(){
+for(var _23="",_24=[],i=0;i<arguments.length;i++){
+_23+="var "+_22.names[i]+"= arguments["+i+"]; ";
+_24.push(arguments[i]);
+}
+eval(_23);
+var _25=_20.module,_26=[],_27={},_28=[],p,_29={provide:function(_2a){
+_2a=_9(_2a);
+var _2b=_13(_2a,_25);
+if(_2b!==_25){
+_53(_2b);
+}
+},require:function(_2c,_2d){
+_2c=_9(_2c);
+_2d&&(_13(_2c,_25).result=_4e);
+_28.push(_2c);
+},requireLocalization:function(_2e,_2f,_30){
+_26.length||(_26=["dojo/i18n"]);
+_30=(_30||_1.locale).toLowerCase();
+_2e=_9(_2e)+"/nls/"+(/root/i.test(_30)?"":_30+"/")+_9(_2f);
+if(_13(_2e,_25).isXd){
+_26.push("dojo/i18n!"+_2e);
+}
+},loadInit:function(f){
+f();
+}};
+try{
+for(p in _29){
+_27[p]=_1[p];
+_1[p]=_29[p];
+}
+_22.def.apply(null,_24);
+}
+catch(e){
+_54("error",[_8("failedDojoLoadInit"),e]);
+}
+finally{
+for(p in _29){
+_1[p]=_27[p];
+}
+}
+_28.length&&_26.push("dojo/require!"+_28.join(","));
+_c.push(_21);
+_7.forEach(_28,function(mid){
+var _31=_13(mid,_20.module);
+_d.push(_31);
+_14(_31);
+});
+_15();
+});
+});
+},_32=function(_33,_34,_35){
+var _36=/\(|\)/g,_37=1,_38;
+_36.lastIndex=_34;
+while((_38=_36.exec(_33))){
+if(_38[0]==")"){
+_37-=1;
+}else{
+_37+=1;
+}
+if(_37==0){
+break;
+}
+}
+if(_37!=0){
+throw "unmatched paren around character "+_36.lastIndex+" in: "+_33;
+}
+return [_1.trim(_33.substring(_35,_36.lastIndex))+";\n",_36.lastIndex];
+},_39=/(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg,_3a=/(^|\s)dojo\.(loadInit|require|provide|requireLocalization|requireIf|requireAfterIf|platformRequire)\s*\(/mg,_3b=/(^|\s)(require|define)\s*\(/m,_3c=function(_3d,_3e){
+var _3f,_40,_41,_42,_43=[],_44=[],_45=[];
+_3e=_3e||_3d.replace(_39,function(_46){
+_3a.lastIndex=_3b.lastIndex=0;
+return (_3a.test(_46)||_3b.test(_46))?"":_46;
+});
+while((_3f=_3a.exec(_3e))){
+_40=_3a.lastIndex;
+_41=_40-_3f[0].length;
+_42=_32(_3e,_40,_41);
+if(_3f[2]=="loadInit"){
+_43.push(_42[0]);
+}else{
+_44.push(_42[0]);
+}
+_3a.lastIndex=_42[1];
+}
+_45=_43.concat(_44);
+if(_45.length||!_3b.test(_3e)){
+return [_3d.replace(/(^|\s)dojo\.loadInit\s*\(/g,"\n0 && dojo.loadInit("),_45.join(""),_45];
+}else{
+return 0;
+}
+},_47=function(_48,_49){
+var _4a,id,_4b=[],_4c=[];
+if(_b.test(_49)||!(_4a=_3c(_49))){
+return 0;
+}
+id=_48.mid+"-*loadInit";
+for(var p in _13("dojo",_48).result.scopeMap){
+_4b.push(p);
+_4c.push("\""+p+"\"");
+}
+return "// xdomain rewrite of "+_48.path+"\n"+"define('"+id+"',{\n"+"\tnames:"+_1.toJson(_4b)+",\n"+"\tdef:function("+_4b.join(",")+"){"+_4a[1]+"}"+"});\n\n"+"define("+_1.toJson(_4b.concat(["dojo/loadInit!"+id]))+", function("+_4b.join(",")+"){\n"+_4a[0]+"});";
+},_1d=_3.initSyncLoader(_e,_15,_47),_4d=_1d.sync,xd=_1d.xd,_1c=_1d.arrived,_4e=_1d.nonmodule,_4f=_1d.executing,_50=_1d.executed,_51=_1d.syncExecStack,_1b=_1d.modules,_52=_1d.execQ,_13=_1d.getModule,_14=_1d.injectModule,_53=_1d.setArrived,_54=_1d.signal,_55=_1d.finishExec,_56=_1d.execModule,_57=_1d.getLegacyMode;
+_1.provide=function(mid){
+var _58=_51[0],_59=_6.mixin(_13(_9(mid),_3.module),{executed:_4f,result:_6.getObject(mid,true)});
+_53(_59);
+if(_58){
+(_58.provides||(_58.provides=[])).push(function(){
+_59.result=_6.getObject(mid);
+delete _59.provides;
+_59.executed!==_50&&_55(_59);
+});
+}
+return _59.result;
+};
+_2.add("config-publishRequireResult",1,0,0);
+_1.require=function(_5a,_5b){
+function _5c(mid,_5d){
+var _5e=_13(_9(mid),_3.module);
+if(_51.length&&_51[0].finish){
+_51[0].finish.push(mid);
+return undefined;
+}
+if(_5e.executed){
+return _5e.result;
+}
+_5d&&(_5e.result=_4e);
+var _5f=_57();
+_14(_5e);
+_5f=_57();
+if(_5e.executed!==_50&&_5e.injected===_1c){
+_1d.holdIdle();
+_56(_5e);
+_1d.releaseIdle();
+}
+if(_5e.executed){
+return _5e.result;
+}
+if(_5f==_4d){
+if(_5e.cjs){
+_52.unshift(_5e);
+}else{
+_51.length&&(_51[0].finish=[mid]);
+}
+}else{
+_52.push(_5e);
+}
+return undefined;
+};
+var _60=_5c(_5a,_5b);
+if(_2("config-publishRequireResult")&&!_6.exists(_5a)&&_60!==undefined){
+_6.setObject(_5a,_60);
+}
+return _60;
+};
+_1.loadInit=function(f){
+f();
+};
+_1.registerModulePath=function(_61,_62){
+var _63={};
+_63[_61.replace(/\./g,"/")]=_62;
+_3({paths:_63});
+};
+_1.platformRequire=function(_64){
+var _65=(_64.common||[]).concat(_64[_1._name]||_64["default"]||[]),_66;
+while(_65.length){
+if(_6.isArray(_66=_65.shift())){
+_1.require.apply(_1,_66);
+}else{
+_1.require(_66);
+}
+}
+};
+_1.requireIf=_1.requireAfterIf=function(_67,_68,_69){
+if(_67){
+_1.require(_68,_69);
+}
+};
+_1.requireLocalization=function(_6a,_6b,_6c){
+_3(["../i18n"],function(_6d){
+_6d.getLocalization(_6a,_6b,_6c);
+});
+};
+return {extractLegacyApiApplications:_3c,require:_1d.dojoRequirePlugin,loadInit:_1f};
+});

data/vendor/assets/javascripts/dojo/_base/loader.js.uncompressed.js

@@ -0,0 +1,718 @@
+define("dojo/_base/loader", ["./kernel", "../has", "require", "module", "./json", "./lang", "./array"], function(dojo, has, require, thisModule, json, lang, array) {
+	// module:
+	//		dojo/_base/lader
+	// summary:
+	//		This module defines the v1.x synchronous loader API.
+
+	// signal the loader in sync mode...
+	//>>pure-amd
+
+	if (!1){
+		console.error("cannot load the Dojo v1.x loader with a foreign loader");
+		return 0;
+	}
+
+	var makeErrorToken = function(id){
+			return {src:thisModule.id, id:id};
+		},
+
+		slashName = function(name){
+			return name.replace(/\./g, "/");
+		},
+
+		buildDetectRe = /\/\/>>built/,
+
+		dojoRequireCallbacks = [],
+		dojoRequireModuleStack = [],
+
+		dojoRequirePlugin = function(mid, require, loaded){
+			dojoRequireCallbacks.push(loaded);
+			array.forEach(mid.split(","), function(mid){
+				var module = getModule(mid, require.module);
+				dojoRequireModuleStack.push(module);
+				injectModule(module);
+			});
+			checkDojoRequirePlugin();
+		},
+
+		// checkDojoRequirePlugin inspects all of the modules demanded by a dojo/require!<module-list> dependency
+		// to see if they have arrived. The loader does not release *any* of these modules to be instantiated
+		// until *all* of these modules are on board, thereby preventing the evaluation of a module with dojo.require's
+		// that reference modules that are not available.
+		//
+		// The algorithm works by traversing the dependency graphs (remember, there can be cycles so they are not trees)
+		// of each module in the dojoRequireModuleStack array (which contains the list of modules demanded by dojo/require!).
+		// The moment a single module is discovered that is missing, the algorithm gives up and indicates that not all
+		// modules are on board. dojo/loadInit! and dojo/require! are ignored because there dependencies are inserted
+		// directly in dojoRequireModuleStack. For example, if "your/module" module depends on "dojo/require!my/module", then
+		// *both* "dojo/require!my/module" and "my/module" will be in dojoRequireModuleStack. Obviously, if "my/module"
+		// is on board, then "dojo/require!my/module" is also satisfied, so the algorithm doesn't check for "dojo/require!my/module".
+		//
+		// Note: inserting a dojo/require!<some-module-list> dependency in the dojoRequireModuleStack achieves nothing
+		// with the current algorithm; however, having such modules present makes it possible to optimize the algorithm
+		//
+		// Note: prior versions of this algorithm had an optimization that signaled loaded on dojo/require! dependencies
+		// individually (rather than waiting for them all to be resolved). The implementation proved problematic with cycles
+		// and plugins. However, it is possible to reattach that strategy in the future.
+
+		// a set from module-id to {undefined | 1 | 0}, where...
+		//   undefined => the module has not been inspected
+		//   0 => the module or at least one of its dependencies has not arrived
+		//   1 => the module is a loadInit! or require! plugin resource, or is currently being traversed (therefore, assume
+		//        OK until proven otherwise), or has been completely traversed and all dependencies have arrived
+		touched,
+
+		traverse = function(m){
+		    touched[m.mid] = 1;
+			for(var t, module, deps = m.deps || [], i= 0; i<deps.length; i++){
+				module = deps[i];
+				if(!(t = touched[module.mid])){
+					if(t===0 || !traverse(module)){
+						touched[m.mid] = 0;
+						return false;
+					}
+				}
+			}
+			return true;
+		},
+
+		checkDojoRequirePlugin = function(){
+			// initialize the touched hash with easy-to-compute values that help short circuit recursive algorithm;
+			// recall loadInit/require plugin modules are dependencies of modules in dojoRequireModuleStack...
+			// which would cause a circular dependency chain that would never be resolved if checked here
+			// notice all dependencies of any particular loadInit/require plugin module will already
+			// be checked since those are pushed into dojoRequireModuleStack explicitly by the
+			// plugin...so if a particular loadInitPlugin module's dependencies are not really
+			// on board, that *will* be detected elsewhere in the traversal.
+			var module, mid;
+			touched = {};
+			for(mid in modules){
+				module = modules[mid];
+				// this could be improved by remembering the result of the regex tests
+				if(module.executed || module.noReqPluginCheck){
+					touched[mid] = 1;
+				}else{
+					if(module.noReqPluginCheck!==0){
+						// tag the module as either a loadInit or require plugin or not for future reference
+						module.noReqPluginCheck = /loadInit\!/.test(mid) || /require\!/.test(mid) ? 1 : 0;
+					}
+					if(module.noReqPluginCheck){
+						touched[mid] = 1;
+					}else if(module.injected!==arrived){
+						// not executed, has not arrived, and is not a loadInit or require plugin resource
+						touched[mid] = 0;
+					}// else, leave undefined and we'll traverse the dependencies
+				}
+			}
+
+			for(var t, i = 0, end = dojoRequireModuleStack.length; i<end; i++){
+				module = dojoRequireModuleStack[i];
+				if(!(t = touched[module.mid])){
+					if(t===0 || !traverse(module)){
+						return;
+					}
+				}
+			}
+			loaderVars.holdIdle();
+			var oldCallbacks = dojoRequireCallbacks;
+			dojoRequireCallbacks = [];
+			array.forEach(oldCallbacks, function(cb){cb(1);});
+			loaderVars.releaseIdle();
+		},
+
+		dojoLoadInitPlugin = function(mid, require, loaded){
+			// mid names a module that defines a "dojo load init" bundle, an object with two properties:
+			//
+			//   * names: a vector of module ids that give top-level names to define in the lexical scope of def
+			//   * def: a function that contains some some legacy loader API applications
+			//
+			// The point of def is to possibly cause some modules to be loaded (but not executed) by dojo/require! where the module
+			// ids are possibly-determined at runtime. For example, here is dojox.gfx from v1.6 expressed as an AMD module using the dojo/loadInit
+			// and dojo/require plugins.
+			//
+			// // dojox/gfx:
+			//
+			//   define("*loadInit_12, {
+			//     names:["dojo", "dijit", "dojox"],
+			//     def: function(){
+			//       dojo.loadInit(function(){
+			//         var gfx = lang.getObject("dojox.gfx", true);
+			//
+			//         //
+			//         // code required to set gfx properties ommitted...
+			//         //
+			//
+			//         // now use the calculations to include the runtime-dependent module
+			//         dojo.require("dojox.gfx." + gfx.renderer);
+			//       });
+			//	   }
+			//   });
+			//
+			//   define(["dojo", "dojo/loadInit!" + id].concat("dojo/require!dojox/gfx/matric,dojox/gfx/_base"), function(dojo){
+			//     // when this AMD factory function is executed, the following modules are guaranteed downloaded but not executed:
+			//     //   "dojox.gfx." + gfx.renderer
+			//     //   dojox.gfx.matrix
+			//     //   dojox.gfx._base
+			//     dojo.provide("dojo.gfx");
+			//     dojo.require("dojox.gfx.matrix");
+			//     dojo.require("dojox.gfx._base");
+			//     dojo.require("dojox.gfx." + gfx.renderer);
+			//     return lang.getObject("dojo.gfx");
+			//   });
+			//  })();
+			//
+			// The idea is to run the legacy loader API with global variables shadowed, which allows these variables to
+			// be relocated. For example, dojox and dojo could be relocated to different names by giving a packageMap and the code above will
+			// execute properly (because the plugin below resolves the load init bundle.names module with respect to the module that demanded
+			// the plugin resource).
+			//
+			// Note that the relocation is specified in the runtime configuration; relocated names need not be set at build-time.
+			//
+			// Warning: this is not the best way to express dojox.gfx as and AMD module. In fact, the module has been properly converted in
+			// v1.7. However, this technique allows the builder to convert legacy modules into AMD modules and guarantee the codepath is the
+			// same in the converted AMD module.
+			require([mid], function(bundle){
+				// notice how names is resolved with respect to the module that demanded the plugin resource
+				require(bundle.names, function(){
+					// bring the bundle names into scope
+					for(var scopeText = "", args= [], i = 0; i<arguments.length; i++){
+						scopeText+= "var " + bundle.names[i] + "= arguments[" + i + "]; ";
+						args.push(arguments[i]);
+					}
+					eval(scopeText);
+
+					var callingModule = require.module,
+						deps = [],
+						hold = {},
+						requireList = [],
+						p,
+						syncLoaderApi = {
+							provide:function(moduleName){
+								// mark modules that arrive consequent to multiple provides in this module as arrived since they can't be injected
+								moduleName = slashName(moduleName);
+								var providedModule = getModule(moduleName, callingModule);
+								if(providedModule!==callingModule){
+									setArrived(providedModule);
+								}
+							},
+							require:function(moduleName, omitModuleCheck){
+								moduleName = slashName(moduleName);
+								omitModuleCheck && (getModule(moduleName, callingModule).result = nonmodule);
+								requireList.push(moduleName);
+							},
+							requireLocalization:function(moduleName, bundleName, locale){
+								// since we're going to need dojo/i8n, add it to deps if not already there
+								deps.length || (deps = ["dojo/i18n"]);
+
+								// figure out if the bundle is xdomain; if so, add it to the depsSet
+								locale = (locale || dojo.locale).toLowerCase();
+								moduleName = slashName(moduleName) + "/nls/" + (/root/i.test(locale) ? "" : locale + "/") + slashName(bundleName);
+								if(getModule(moduleName, callingModule).isXd){
+									deps.push("dojo/i18n!" + moduleName);
+								}// else the bundle will be loaded synchronously when the module is evaluated
+							},
+							loadInit:function(f){
+								f();
+							}
+						};
+
+					// hijack the correct dojo and apply bundle.def
+					try{
+						for(p in syncLoaderApi){
+							hold[p] = dojo[p];
+							dojo[p] = syncLoaderApi[p];
+						}
+						bundle.def.apply(null, args);
+					}catch(e){
+						signal("error", [makeErrorToken("failedDojoLoadInit"), e]);
+					}finally{
+						for(p in syncLoaderApi){
+							dojo[p] = hold[p];
+						}
+					}
+
+					// requireList is the list of modules that need to be downloaded but not executed before the callingModule can be executed
+					requireList.length && deps.push("dojo/require!" + requireList.join(","));
+
+					dojoRequireCallbacks.push(loaded);
+					array.forEach(requireList, function(mid){
+						var module = getModule(mid, require.module);
+						dojoRequireModuleStack.push(module);
+						injectModule(module);
+					});
+					checkDojoRequirePlugin();
+				});
+			});
+		},
+
+		extractApplication = function(
+			text,             // the text to search
+			startSearch,      // the position in text to start looking for the closing paren
+			startApplication  // the position in text where the function application expression starts
+		){
+			// find end of the call by finding the matching end paren
+			// Warning: as usual, this will fail in the presense of unmatched right parans contained in strings, regexs, or unremoved comments
+			var parenRe = /\(|\)/g,
+				matchCount = 1,
+				match;
+			parenRe.lastIndex = startSearch;
+			while((match = parenRe.exec(text))){
+				if(match[0] == ")"){
+					matchCount -= 1;
+				}else{
+					matchCount += 1;
+				}
+				if(matchCount == 0){
+					break;
+				}
+			}
+
+			if(matchCount != 0){
+				throw "unmatched paren around character " + parenRe.lastIndex + " in: " + text;
+			}
+
+			//Put the master matching string in the results.
+			return [dojo.trim(text.substring(startApplication, parenRe.lastIndex))+";\n", parenRe.lastIndex];
+		},
+
+		// the following regex is taken from 1.6. It is a very poor technique to remove comments and
+		// will fail in some cases; for example, consider the code...
+		//
+		//    var message = "Category-1 */* Category-2";
+		//
+		// The regex that follows will see a /* comment and trash the code accordingly. In fact, there are all
+		// kinds of cases like this with strings and regexs that will cause this design to fail miserably.
+		//
+		// Alternative regex designs exist that will result in less-likely failures, but will still fail in many cases.
+		// The only solution guaranteed 100% correct is to parse the code and that seems overkill for this
+		// backcompat/unbuilt-xdomain layer. In the end, since it's been this way for a while, we won't change it.
+		// See the opening paragraphs of Chapter 7 or ECME-262 which describes the lexical abiguity further.
+		removeCommentRe = /(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg,
+
+		syncLoaderApiRe = /(^|\s)dojo\.(loadInit|require|provide|requireLocalization|requireIf|requireAfterIf|platformRequire)\s*\(/mg,
+
+		amdLoaderApiRe = /(^|\s)(require|define)\s*\(/m,
+
+		extractLegacyApiApplications = function(text, noCommentText){
+			// scan the noCommentText for any legacy loader API applications. Copy such applications into result (this is
+			// used by the builder). Move dojo.loadInit applications to loadInitApplications string. Copy all other applications
+			// to otherApplications string. If no applications were found, return 0, signalling an AMD module. Otherwise, return
+			// loadInitApplications + otherApplications. Fixup text by replacing
+			//
+			//   dojo.loadInit(// etc...
+			//
+			// with
+			//
+			//   \n 0 && dojo.loadInit(// etc...
+			//
+			// Which results in the dojo.loadInit from *not* being applied. This design goes a long way towards protecting the
+			// code from an over-agressive removeCommentRe. However...
+			//
+			// WARNING: the removeCommentRe will cause an error if a detected comment removes all or part of a legacy-loader application
+			// that is not in a comment.
+
+			var match, startSearch, startApplication, application,
+				loadInitApplications = [],
+				otherApplications = [],
+				allApplications = [];
+
+			// noCommentText may be provided by a build app with comments extracted by a better method than regex (hopefully)
+			noCommentText = noCommentText || text.replace(removeCommentRe, function(match){
+				// remove iff the detected comment has text that looks like a sync loader API application; this helps by
+				// removing as little as possible, minimizing the changes the janky regex will kill the module
+				syncLoaderApiRe.lastIndex = amdLoaderApiRe.lastIndex = 0;
+				return (syncLoaderApiRe.test(match) || amdLoaderApiRe.test(match)) ? "" : match;
+			});
+
+			// find and extract all dojo.loadInit applications
+			while((match = syncLoaderApiRe.exec(noCommentText))){
+				startSearch = syncLoaderApiRe.lastIndex;
+				startApplication = startSearch  - match[0].length;
+				application = extractApplication(noCommentText, startSearch, startApplication);
+				if(match[2]=="loadInit"){
+					loadInitApplications.push(application[0]);
+				}else{
+					otherApplications.push(application[0]);
+				}
+				syncLoaderApiRe.lastIndex = application[1];
+			}
+			allApplications = loadInitApplications.concat(otherApplications);
+			if(allApplications.length || !amdLoaderApiRe.test(noCommentText)){
+				// either there were some legacy loader API applications or there were no AMD API applications
+				return [text.replace(/(^|\s)dojo\.loadInit\s*\(/g, "\n0 && dojo.loadInit("), allApplications.join(""), allApplications];
+			}else{
+				// legacy loader API *was not* detected and AMD API *was* detected; therefore, assume it's an AMD module
+				return 0;
+			}
+		},
+
+		transformToAmd = function(module, text){
+			// This is roughly the equivalent of dojo._xdCreateResource in 1.6-; however, it expresses a v1.6- dojo
+			// module in terms of AMD define instead of creating the dojo proprietary xdomain module expression.
+			// The module could have originated from several sources:
+			//
+			//   * amd require() a module, e.g., require(["my/module"])
+			//   * amd require() a nonmodule, e.g., require(["my/resource.js"')
+			//   * amd define() deps vector (always a module)
+			//   * dojo.require() a module, e.g. dojo.require("my.module")
+			//   * dojo.require() a nonmodule, e.g., dojo.require("my.module", true)
+			//   * dojo.requireIf/requireAfterIf/platformRequire a module
+			//
+			// The module is scanned for legacy loader API applications; if none are found, then assume the module is an
+			// AMD module and return 0. Otherwise, a synthetic dojo/loadInit plugin resource is created and the module text
+			// is rewritten as an AMD module with the single dependency of this synthetic resource. When the dojo/loadInit
+			// plugin loaded the synthetic resource, it will cause all dojo.loadInit's to be executed, find all dojo.require's
+			// (either directly consequent to dojo.require or indirectly consequent to dojo.require[After]If or
+			// dojo.platformRequire, and finally cause loading of all dojo.required modules with the dojo/require plugin. Thus,
+			// when the dojo/loadInit plugin reports it has been loaded, all modules required by the given module are guaranteed
+			// loaded (but not executed). This then allows the module to execute it's code path without interupts, thereby
+			// following the synchronous code path.
+
+			var extractResult, id, names = [], namesAsStrings = [];
+			if(buildDetectRe.test(text) || !(extractResult = extractLegacyApiApplications(text))){
+				// buildDetectRe.test(text) => a built module, always AMD
+				// extractResult==0 => no sync API
+				return 0;
+			}
+
+			// manufacture a synthetic module id that can never be a real mdule id (just like require does)
+			id = module.mid + "-*loadInit";
+
+			// construct the dojo/loadInit names vector which causes any relocated names to be defined as lexical variables under their not-relocated name
+			// the dojo/loadInit plugin assumes the first name in names is "dojo"
+
+			for(var p in getModule("dojo", module).result.scopeMap){
+				names.push(p);
+				namesAsStrings.push('"' + p + '"');
+			}
+
+			// rewrite the module as a synthetic dojo/loadInit plugin resource + the module expressed as an AMD module that depends on this synthetic resource
+			return "// xdomain rewrite of " + module.path + "\n" +
+				"define('" + id + "',{\n" +
+				"\tnames:" + dojo.toJson(names) + ",\n" +
+				"\tdef:function(" + names.join(",") + "){" + extractResult[1] + "}" +
+				"});\n\n" +
+			    "define(" + dojo.toJson(names.concat(["dojo/loadInit!"+id])) + ", function(" + names.join(",") + "){\n" + extractResult[0] + "});";
+		},
+
+		loaderVars = require.initSyncLoader(dojoRequirePlugin, checkDojoRequirePlugin, transformToAmd),
+
+		sync =
+			loaderVars.sync,
+
+		xd =
+			loaderVars.xd,
+
+		arrived =
+			loaderVars.arrived,
+
+		nonmodule =
+			loaderVars.nonmodule,
+
+		executing =
+			loaderVars.executing,
+
+		executed =
+			loaderVars.executed,
+
+		syncExecStack =
+			loaderVars.syncExecStack,
+
+		modules =
+			loaderVars.modules,
+
+		execQ =
+			loaderVars.execQ,
+
+		getModule =
+			loaderVars.getModule,
+
+		injectModule =
+			loaderVars.injectModule,
+
+		setArrived =
+			loaderVars.setArrived,
+
+		signal =
+			loaderVars.signal,
+
+		finishExec =
+			loaderVars.finishExec,
+
+		execModule =
+			loaderVars.execModule,
+
+		getLegacyMode =
+			loaderVars.getLegacyMode;
+
+	dojo.provide = function(mid){
+		var executingModule = syncExecStack[0],
+			module = lang.mixin(getModule(slashName(mid), require.module), {
+				executed:executing,
+				result:lang.getObject(mid, true)
+			});
+		setArrived(module);
+		if(executingModule){
+			(executingModule.provides || (executingModule.provides = [])).push(function(){
+				module.result = lang.getObject(mid);
+				delete module.provides;
+				module.executed!==executed && finishExec(module);
+			});
+		}// else dojo.provide called not consequent to loading; therefore, give up trying to publish module value to loader namespace
+		return module.result;
+	};
+
+	has.add("config-publishRequireResult", 1, 0, 0);
+
+	dojo.require = function(moduleName, omitModuleCheck) {
+		//	summary:
+		//		loads a Javascript module from the appropriate URI
+		//
+		//	moduleName: String
+		//		module name to load, using periods for separators,
+		//		 e.g. "dojo.date.locale".  Module paths are de-referenced by dojo's
+		//		internal mapping of locations to names and are disambiguated by
+		//		longest prefix. See `dojo.registerModulePath()` for details on
+		//		registering new modules.
+		//
+		//	omitModuleCheck: Boolean?
+		//		if `true`, omitModuleCheck skips the step of ensuring that the
+		//		loaded file actually defines the symbol it is referenced by.
+		//		For example if it called as `dojo.require("a.b.c")` and the
+		//		file located at `a/b/c.js` does not define an object `a.b.c`,
+		//		and exception will be throws whereas no exception is raised
+		//		when called as `dojo.require("a.b.c", true)`
+		//
+		//	description:
+		// 		Modules are loaded via dojo.require by using one of two loaders: the normal loader
+		// 		and the xdomain loader. The xdomain loader is used when dojo was built with a
+		// 		custom build that specified loader=xdomain and the module lives on a modulePath
+		// 		that is a whole URL, with protocol and a domain. The versions of Dojo that are on
+		// 		the Google and AOL CDNs use the xdomain loader.
+		//
+		// 		If the module is loaded via the xdomain loader, it is an asynchronous load, since
+		// 		the module is added via a dynamically created script tag. This
+		// 		means that dojo.require() can return before the module has loaded. However, this
+		// 		should only happen in the case where you do dojo.require calls in the top-level
+		// 		HTML page, or if you purposely avoid the loader checking for dojo.require
+		// 		dependencies in your module by using a syntax like dojo["require"] to load the module.
+		//
+		// 		Sometimes it is useful to not have the loader detect the dojo.require calls in the
+		// 		module so that you can dynamically load the modules as a result of an action on the
+		// 		page, instead of right at module load time.
+		//
+		// 		Also, for script blocks in an HTML page, the loader does not pre-process them, so
+		// 		it does not know to download the modules before the dojo.require calls occur.
+		//
+		// 		So, in those two cases, when you want on-the-fly module loading or for script blocks
+		// 		in the HTML page, special care must be taken if the dojo.required code is loaded
+		// 		asynchronously. To make sure you can execute code that depends on the dojo.required
+		// 		modules, be sure to add the code that depends on the modules in a dojo.addOnLoad()
+		// 		callback. dojo.addOnLoad waits for all outstanding modules to finish loading before
+		// 		executing.
+		//
+		// 		This type of syntax works with both xdomain and normal loaders, so it is good
+		// 		practice to always use this idiom for on-the-fly code loading and in HTML script
+		// 		blocks. If at some point you change loaders and where the code is loaded from,
+		// 		it will all still work.
+		//
+		// 		More on how dojo.require
+		//		`dojo.require("A.B")` first checks to see if symbol A.B is
+		//		defined. If it is, it is simply returned (nothing to do).
+		//
+		//		If it is not defined, it will look for `A/B.js` in the script root
+		//		directory.
+		//
+		//		`dojo.require` throws an exception if it cannot find a file
+		//		to load, or if the symbol `A.B` is not defined after loading.
+		//
+		//		It returns the object `A.B`, but note the caveats above about on-the-fly loading and
+		// 		HTML script blocks when the xdomain loader is loading a module.
+		//
+		//		`dojo.require()` does nothing about importing symbols into
+		//		the current namespace.  It is presumed that the caller will
+		//		take care of that.
+		//
+		// 	example:
+		// 		To use dojo.require in conjunction with dojo.ready:
+		//
+		//		|	dojo.require("foo");
+		//		|	dojo.require("bar");
+		//	   	|	dojo.addOnLoad(function(){
+		//	   	|		//you can now safely do something with foo and bar
+		//	   	|	});
+		//
+		//	example:
+		//		For example, to import all symbols into a local block, you might write:
+		//
+		//		|	with (dojo.require("A.B")) {
+		//		|		...
+		//		|	}
+		//
+		//		And to import just the leaf symbol to a local variable:
+		//
+		//		|	var B = dojo.require("A.B");
+		//	   	|	...
+		//
+		//	returns:
+		//		the required namespace object
+		function doRequire(mid, omitModuleCheck){
+			var module = getModule(slashName(mid), require.module);
+			if(syncExecStack.length && syncExecStack[0].finish){
+				// switched to async loading in the middle of evaluating a legacy module; stop
+				// applying dojo.require so the remaining dojo.requires are applied in order
+				syncExecStack[0].finish.push(mid);
+				return undefined;
+			}
+
+			// recall module.executed has values {0, executing, executed}; therefore, truthy indicates executing or executed
+			if(module.executed){
+				return module.result;
+			}
+			omitModuleCheck && (module.result = nonmodule);
+
+			var currentMode = getLegacyMode();
+
+			// recall, in sync mode to inject is to *eval* the module text
+			// if the module is a legacy module, this is the same as executing
+			// but if the module is an AMD module, this means defining, not executing
+			injectModule(module);
+			// the inject may have changed the mode
+			currentMode = getLegacyMode();
+
+			// in sync mode to dojo.require is to execute
+			if(module.executed!==executed && module.injected===arrived){
+				// the module was already here before injectModule was called probably finishing up a xdomain
+				// load, but maybe a module given to the loader directly rather than having the loader retrieve it
+				loaderVars.holdIdle();
+				execModule(module);
+				loaderVars.releaseIdle();
+			}
+			if(module.executed){
+				return module.result;
+			}
+
+			if(currentMode==sync){
+				// the only way to get here is in sync mode and dojo.required a module that
+				//   * was loaded async in the injectModule application a few lines up
+				//   * was an AMD module that had deps that are being loaded async and therefore couldn't execute
+				if(module.cjs){
+					// the module was an AMD module; unshift, not push, which causes the current traversal to be reattempted from the top
+					execQ.unshift(module);
+				}else{
+					// the module was a legacy module
+					syncExecStack.length && (syncExecStack[0].finish= [mid]);
+				}
+			}else{
+				// the loader wasn't in sync mode on entry; probably async mode; therefore, no expectation of getting
+				// the module value synchronously; make sure it gets executed though
+				execQ.push(module);
+			}
+			return undefined;
+		}
+
+		var result = doRequire(moduleName, omitModuleCheck);
+		if(has("config-publishRequireResult") && !lang.exists(moduleName) && result!==undefined){
+			lang.setObject(moduleName, result);
+		}
+		return result;
+	};
+
+	dojo.loadInit = function(f) {
+		f();
+	};
+
+	dojo.registerModulePath = function(/*String*/moduleName, /*String*/prefix){
+		//	summary:
+		//		Maps a module name to a path
+		//	description:
+		//		An unregistered module is given the default path of ../[module],
+		//		relative to Dojo root. For example, module acme is mapped to
+		//		../acme.  If you want to use a different module name, use
+		//		dojo.registerModulePath.
+		//	example:
+		//		If your dojo.js is located at this location in the web root:
+		//	|	/myapp/js/dojo/dojo/dojo.js
+		//		and your modules are located at:
+		//	|	/myapp/js/foo/bar.js
+		//	|	/myapp/js/foo/baz.js
+		//	|	/myapp/js/foo/thud/xyzzy.js
+		//		Your application can tell Dojo to locate the "foo" namespace by calling:
+		//	|	dojo.registerModulePath("foo", "../../foo");
+		//		At which point you can then use dojo.require() to load the
+		//		modules (assuming they provide() the same things which are
+		//		required). The full code might be:
+		//	|	<script type="text/javascript"
+		//	|		src="/myapp/js/dojo/dojo/dojo.js"></script>
+		//	|	<script type="text/javascript">
+		//	|		dojo.registerModulePath("foo", "../../foo");
+		//	|		dojo.require("foo.bar");
+		//	|		dojo.require("foo.baz");
+		//	|		dojo.require("foo.thud.xyzzy");
+		//	|	</script>
+
+		var paths = {};
+		paths[moduleName.replace(/\./g, "/")] = prefix;
+		require({paths:paths});
+	};
+
+	dojo.platformRequire = function(/*Object*/modMap){
+		//	summary:
+		//		require one or more modules based on which host environment
+		//		Dojo is currently operating in
+		//	description:
+		//		This method takes a "map" of arrays which one can use to
+		//		optionally load dojo modules. The map is indexed by the
+		//		possible dojo.name_ values, with two additional values:
+		//		"default" and "common". The items in the "default" array will
+		//		be loaded if none of the other items have been choosen based on
+		//		dojo.name_, set by your host environment. The items in the
+		//		"common" array will *always* be loaded, regardless of which
+		//		list is chosen.
+		//	example:
+ 		//		|	dojo.platformRequire({
+		//		|		browser: [
+		//		|			"foo.sample", // simple module
+		//		|			"foo.test",
+		//		|			["foo.bar.baz", true] // skip object check in _loadModule (dojo.require)
+		//		|		],
+		//		|		default: [ "foo.sample._base" ],
+		//		|		common: [ "important.module.common" ]
+		//		|	});
+
+		var result = (modMap.common || []).concat(modMap[dojo._name] || modMap["default"] || []),
+			temp;
+		while(result.length){
+			if(lang.isArray(temp = result.shift())){
+				dojo.require.apply(dojo, temp);
+			}else{
+				dojo.require(temp);
+			}
+		}
+	};
+
+	dojo.requireIf = dojo.requireAfterIf = function(/*Boolean*/ condition, /*String*/ moduleName, /*Boolean?*/omitModuleCheck){
+		// summary:
+		//		If the condition is true then call `dojo.require()` for the specified
+		//		resource
+		//
+		// example:
+		//	|	dojo.requireIf(dojo.isBrowser, "my.special.Module");
+
+		if(condition){
+			dojo.require(moduleName, omitModuleCheck);
+		}
+	};
+
+	dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale){
+		require(["../i18n"], function(i18n){
+			i18n.getLocalization(moduleName, bundleName, locale);
+		});
+	};
+
+	return {
+		extractLegacyApiApplications:extractLegacyApiApplications,
+		require:loaderVars.dojoRequirePlugin,
+		loadInit:dojoLoadInitPlugin
+	};
+});