dojo-rails 0.9.8 → 0.9.9

data/vendor/assets/javascripts/dojo/i18n.js

@@ -0,0 +1,211 @@
+/*
+	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/i18n",["./_base/kernel","require","./has","./_base/array","./_base/config","./_base/lang","./_base/xhr","./json"],function(_1,_2,_3,_4,_5,_6,_7,_8){
+_3.add("dojo-preload-i18n-Api",1);
+true||_3.add("dojo-v1x-i18n-Api",1);
+var _9=_1.i18n={},_a=/(^.*(^|\/)nls)(\/|$)([^\/]*)\/?([^\/]*)/,_b=function(_c,_d,_e,_f){
+for(var _10=[_e+_f],_11=_d.split("-"),_12="",i=0;i<_11.length;i++){
+_12+=(_12?"-":"")+_11[i];
+if(!_c||_c[_12]){
+_10.push(_e+_12+"/"+_f);
+}
+}
+return _10;
+},_13={},_14=_1.getL10nName=function(_15,_16,_17){
+_17=_17?_17.toLowerCase():_1.locale;
+_15="dojo/i18n!"+_15.replace(/\./g,"/");
+_16=_16.replace(/\./g,"/");
+return (/root/i.test(_17))?(_15+"/nls/"+_16):(_15+"/nls/"+_17+"/"+_16);
+},_18=function(_19,_1a,_1b,_1c,_1d,_1e){
+_19([_1a],function(_1f){
+var _20=_6.clone(_1f.root),_21=_b(!_1f._v1x&&_1f,_1d,_1b,_1c);
+_19(_21,function(){
+for(var i=1;i<_21.length;i++){
+_20=_6.mixin(_6.clone(_20),arguments[i]);
+}
+var _22=_1a+"/"+_1d;
+_13[_22]=_20;
+_1e();
+});
+});
+},_23=function(id,_24){
+return /^\./.test(id)?_24(id):id;
+},_25=function(_26){
+var _27=_5.extraLocale||[];
+_27=_6.isArray(_27)?_27:[_27];
+_27.push(_26);
+return _27;
+},_28=function(id,_29,_2a){
+if(_3("dojo-preload-i18n-Api")){
+var _2b=id.split("*"),_2c=_2b[1]=="preload";
+if(_2c){
+if(!_13[id]){
+_13[id]=1;
+_2d(_2b[2],_8.parse(_2b[3]),1);
+}
+_2a(1);
+}
+if(_2c||_2e(id,_29,_2a)){
+return;
+}
+}
+var _2f=_a.exec(id),_30=_2f[1]+"/",_31=_2f[5]||_2f[4],_32=_30+_31,_33=(_2f[5]&&_2f[4]),_34=_33||_1.locale,_35=_32+"/"+_34,_36=_33?[_34]:_25(_34),_37=_36.length,_38=function(){
+if(!--_37){
+_2a(_6.delegate(_13[_35]));
+}
+};
+_4.forEach(_36,function(_39){
+var _3a=_32+"/"+_39;
+if(_3("dojo-preload-i18n-Api")){
+_3b(_3a);
+}
+if(!_13[_3a]){
+_18(_29,_32,_30,_31,_39,_38);
+}else{
+_38();
+}
+});
+};
+if(_3("dojo-unit-tests")){
+var _3c=_9.unitTests=[];
+}
+if(_3("dojo-preload-i18n-Api")||1){
+var _3d=_9.normalizeLocale=function(_3e){
+var _3f=_3e?_3e.toLowerCase():_1.locale;
+return _3f=="root"?"ROOT":_3f;
+},_40=function(mid){
+return (1&&1)?_2.isXdUrl(_2.toUrl(mid+".js")):true;
+},_41=0,_42=[],_2d=_9._preloadLocalizations=function(_43,_44,_45){
+function _46(_47,_48){
+var _49=_47.split("-");
+while(_49.length){
+if(_48(_49.join("-"))){
+return true;
+}
+_49.pop();
+}
+return _48("ROOT");
+};
+function _4a(_4b){
+_4b=_3d(_4b);
+_46(_4b,function(loc){
+if(_4.indexOf(_44,loc)>=0){
+var mid=_43.replace(/\./g,"/")+"_"+loc;
+_41++;
+(_40(mid)||_45?_2:_50)([mid],function(_4c){
+for(var p in _4c){
+_13[p+"/"+_4b]=_4c[p];
+}
+--_41;
+while(!_41&&_42.length){
+_28.apply(null,_42.shift());
+}
+});
+return true;
+}
+return false;
+});
+};
+_4a();
+_4.forEach(_1.config.extraLocale,_4a);
+},_2e=function(id,_4d,_4e){
+if(_41){
+_42.push([id,_4d,_4e]);
+}
+return _41;
+};
+}
+if(1){
+var _4f=new Function("__bundle","__checkForLegacyModules","__mid","var define = function(){define.called = 1;},"+"    require = function(){define.called = 1;};"+"try{"+"define.called = 0;"+"eval(__bundle);"+"if(define.called==1)"+"return 1;"+"if((__checkForLegacyModules = __checkForLegacyModules(__mid)))"+"return __checkForLegacyModules;"+"}catch(e){}"+"try{"+"return eval('('+__bundle+')');"+"}catch(e){"+"return e;"+"}"),_50=function(_51,_52){
+var _53=[];
+_4.forEach(_51,function(mid){
+var url=_2.toUrl(mid+".js");
+function _28(_54){
+var _55=_4f(_54,_3b,mid);
+if(_55===1){
+_2([mid],function(_56){
+_53.push(_13[url]=_56);
+});
+}else{
+if(_55 instanceof Error){
+console.error("failed to evaluate i18n bundle; url="+url,_55);
+_55={};
+}
+_53.push(_13[url]=(/nls\/[^\/]+\/[^\/]+$/.test(url)?_55:{root:_55,_v1x:1}));
+}
+};
+if(_13[url]){
+_53.push(_13[url]);
+}else{
+var _57=_2.syncLoadNls(mid);
+if(_57){
+_53.push(_57);
+}else{
+if(!_7){
+try{
+_2.getText(url,true,_28);
+}
+catch(e){
+_53.push(_13[url]={});
+}
+}else{
+_7.get({url:url,sync:true,load:_28,error:function(){
+_53.push(_13[url]={});
+}});
+}
+}
+}
+});
+_52&&_52.apply(null,_53);
+},_3b=function(_58){
+for(var _59,_5a=_58.split("/"),_5b=_1.global[_5a[0]],i=1;_5b&&i<_5a.length-1;_5b=_5b[_5a[i++]]){
+}
+if(_5b){
+_59=_5b[_5a[i]];
+if(!_59){
+_59=_5b[_5a[i].replace(/-/g,"_")];
+}
+if(_59){
+_13[_58]=_59;
+}
+}
+return _59;
+};
+_9.getLocalization=function(_5c,_5d,_5e){
+var _5f,_60=_14(_5c,_5d,_5e).substring(10);
+_28(_60,(!_40(_60)?_50:_2),function(_61){
+_5f=_61;
+});
+return _5f;
+};
+if(_3("dojo-unit-tests")){
+_3c.push(function(doh){
+doh.register("tests.i18n.unit",function(t){
+var _62;
+_62=_4f("{prop:1}");
+t.is({prop:1},_62);
+t.is(undefined,_62[1]);
+_62=_4f("({prop:1})");
+t.is({prop:1},_62);
+t.is(undefined,_62[1]);
+_62=_4f("{'prop-x':1}");
+t.is({"prop-x":1},_62);
+t.is(undefined,_62[1]);
+_62=_4f("({'prop-x':1})");
+t.is({"prop-x":1},_62);
+t.is(undefined,_62[1]);
+_62=_4f("define({'prop-x':1})");
+t.is(1,_62);
+_62=_4f("this is total nonsense and should throw an error");
+t.is(_62 instanceof Error,true);
+});
+});
+}
+}
+return _6.mixin(_9,{dynamic:true,normalize:_23,load:_28,cache:_13});
+});

data/vendor/assets/javascripts/dojo/i18n.js.uncompressed.js

@@ -0,0 +1,514 @@
+define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_base/config", "./_base/lang", "./_base/xhr", "./json"],
+	function(dojo, require, has, array, config, lang, xhr, json) {
+	// module:
+	//		dojo/i18n
+	// summary:
+	//		This module implements the !dojo/i18n plugin and the v1.6- i18n API
+	// description:
+	//		We choose to include our own plugin to leverage functionality already contained in dojo
+	//		and thereby reduce the size of the plugin compared to various loader implementations. Also, this
+	//		allows foreign AMD loaders to be used without their plugins.
+
+
+	has.add("dojo-preload-i18n-Api",
+		// if true, define the preload localizations machinery
+		1
+	);
+
+	true || has.add("dojo-v1x-i18n-Api",
+		// if true, define the v1.x i18n functions
+		1
+	);
+
+	var
+		thisModule= dojo.i18n=
+			// the dojo.i18n module
+			{},
+
+		nlsRe=
+			// regexp for reconstructing the master bundle name from parts of the regexp match
+			// nlsRe.exec("foo/bar/baz/nls/en-ca/foo") gives:
+			// ["foo/bar/baz/nls/en-ca/foo", "foo/bar/baz/nls/", "/", "/", "en-ca", "foo"]
+			// nlsRe.exec("foo/bar/baz/nls/foo") gives:
+			// ["foo/bar/baz/nls/foo", "foo/bar/baz/nls/", "/", "/", "foo", ""]
+			// so, if match[5] is blank, it means this is the top bundle definition.
+			// courtesy of http://requirejs.org
+			/(^.*(^|\/)nls)(\/|$)([^\/]*)\/?([^\/]*)/,
+
+		getAvailableLocales= function(
+			root,
+			locale,
+			bundlePath,
+			bundleName
+		){
+			// return a vector of module ids containing all available locales with respect to the target locale
+			// For example, assuming:
+			//	 * the root bundle indicates specific bundles for "fr" and "fr-ca",
+			//	 * bundlePath is "myPackage/nls"
+			//	 * bundleName is "myBundle"
+			// Then a locale argument of "fr-ca" would return
+			//	 ["myPackage/nls/myBundle", "myPackage/nls/fr/myBundle", "myPackage/nls/fr-ca/myBundle"]
+			// Notice that bundles are returned least-specific to most-specific, starting with the root.
+			//
+			// If root===false indicates we're working with a pre-AMD i18n bundle that doesn't tell about the available locales;
+			// therefore, assume everything is available and get 404 errors that indicate a particular localization is not available
+			//
+
+			for(var result= [bundlePath + bundleName], localeParts= locale.split("-"), current= "", i= 0; i<localeParts.length; i++){
+				current+= (current ? "-" : "") + localeParts[i];
+				if(!root || root[current]){
+					result.push(bundlePath + current + "/" + bundleName);
+				}
+			}
+			return result;
+		},
+
+		cache= {},
+
+		getL10nName= dojo.getL10nName = function(moduleName, bundleName, locale){
+			locale = locale ? locale.toLowerCase() : dojo.locale;
+			moduleName = "dojo/i18n!" + moduleName.replace(/\./g, "/");
+			bundleName = bundleName.replace(/\./g, "/");
+			return (/root/i.test(locale)) ?
+				(moduleName + "/nls/" + bundleName) :
+				(moduleName + "/nls/" + locale + "/" + bundleName);
+		},
+
+		doLoad = function(require, bundlePathAndName, bundlePath, bundleName, locale, load){
+			// get the root bundle which instructs which other bundles are required to construct the localized bundle
+			require([bundlePathAndName], function(root){
+				var current= lang.clone(root.root),
+					availableLocales= getAvailableLocales(!root._v1x && root, locale, bundlePath, bundleName);
+				require(availableLocales, function(){
+					for (var i= 1; i<availableLocales.length; i++){
+						current= lang.mixin(lang.clone(current), arguments[i]);
+					}
+					// target may not have been resolve (e.g., maybe only "fr" exists when "fr-ca" was requested)
+					var target= bundlePathAndName + "/" + locale;
+					cache[target]= current;
+					load();
+				});
+			});
+		},
+
+		normalize = function(id, toAbsMid){
+			// id may be relative
+			// preload has form *preload*<path>/nls/<module>*<flattened locales> and
+			// therefore never looks like a relative
+			return /^\./.test(id) ? toAbsMid(id) : id;
+		},
+
+		getLocalesToLoad = function(targetLocale){
+			var list = config.extraLocale || [];
+			list = lang.isArray(list) ? list : [list];
+			list.push(targetLocale);
+			return list;
+		},
+
+		load = function(id, require, load){
+			//
+			// id is in one of the following formats
+			//
+			//	1. <path>/nls/<bundle>
+			//		=> load the bundle, localized to config.locale; load all bundles localized to
+			//      config.extraLocale (if any); return the loaded bundle localized to config.locale.
+			//
+			//  2. <path>/nls/<locale>/<bundle>
+			//		=> load then return the bundle localized to <locale>
+			//
+			//  3. *preload*<path>/nls/<module>*<JSON array of available locales>
+			//		=> for config.locale and all config.extraLocale, load all bundles found
+			//		   in the best-matching bundle rollup. A value of 1 is returned, which
+			//         is meaningless other than to say the plugin is executing the requested
+			//         preloads
+			//
+			// In cases 1 and 2, <path> is always normalized to an absolute module id upon entry; see
+			// normalize. In case 3, it <path> is assumed to be absolue; this is arranged by the builder.
+			//
+			// To load a bundle means to insert the bundle into the plugin's cache and publish the bundle
+			// value to the loader. Given <path>, <bundle>, and a particular <locale>, the cache key
+			//
+			//   <path>/nls/<bundle>/<locale>
+			//
+			// will hold the value. Similarly, then plugin will publish this value to the loader by
+			//
+			//   define("<path>/nls/<bundle>/<locale>", <bundle-value>);
+			//
+			// Given this algorithm, other machinery can provide fast load paths be preplacing
+			// values in the plugin's cache, which is public. When a load is demanded the
+			// cache is inspected before starting any loading. Explicitly placing values in the plugin
+			// cache is an advanced/experimental feature that should not be needed; use at your own risk.
+			//
+			// For the normal AMD algorithm, the root bundle is loaded first, which instructs the
+			// plugin what additional localized bundles are required for a particular locale. These
+			// additional locales are loaded and a mix of the root and each progressively-specific
+			// locale is returned. For example:
+			//
+			// 1. The client demands "dojo/i18n!some/path/nls/someBundle
+			//
+			// 2. The loader demands load(some/path/nls/someBundle)
+			//
+			// 3. This plugin require's "some/path/nls/someBundle", which is the root bundle.
+			//
+			// 4. Assuming config.locale is "ab-cd-ef" and the root bundle indicates that localizations
+			//    are available for "ab" and "ab-cd-ef" (note the missing "ab-cd", then the plugin
+			//    requires "some/path/nls/ab/someBundle" and "some/path/nls/ab-cd-ef/someBundle"
+			//
+			// 5. Upon receiving all required bundles, the plugin constructs the value of the bundle
+			//    ab-cd-ef as...
+			//
+			//      mixin(mixin(mixin({}, require("some/path/nls/someBundle"),
+			//        require("some/path/nls/ab/someBundle")),
+			//          require("some/path/nls/ab-cd-ef/someBundle"));
+			//
+			//    This value is inserted into the cache and published to the loader at the
+			//    key/module-id some/path/nls/someBundle/ab-cd-ef.
+			//
+			// The special preload signature (case 3) instructs the plugin to stop servicing all normal requests
+			// (further preload requests will be serviced) until all ongoing preloading has completed.
+			//
+			// The preload signature instructs the plugin that a special rollup module is available that contains
+			// one or more flattened, localized bundles. The JSON array of available locales indicates which locales
+			// are available. Here is an example:
+			//
+			//   *preload*some/path/nls/someModule*["root", "ab", "ab-cd-ef"]
+			//
+			// This indicates the following rollup modules are available:
+			//
+			//   some/path/nls/someModule_ROOT
+			//   some/path/nls/someModule_ab
+			//   some/path/nls/someModule_ab-cd-ef
+			//
+			// Each of these modules is a normal AMD module that contains one or more flattened bundles in a hash.
+			// For example, assume someModule contained the bundles some/bundle/path/someBundle and
+			// some/bundle/path/someOtherBundle, then some/path/nls/someModule_ab would be expressed as folllows:
+			//
+			// define({
+			//   some/bundle/path/someBundle:<value of someBundle, flattened with respect to locale ab>,
+			//   some/bundle/path/someOtherBundle:<value of someOtherBundle, flattened with respect to locale ab>,
+			// });
+			//
+			// E.g., given this design, preloading for locale=="ab" can execute the following algorithm:
+			//
+			// require(["some/path/nls/someModule_ab"], function(rollup){
+			//   for(var p in rollup){
+			//     var id = p + "/ab",
+			//     cache[id] = rollup[p];
+			//     define(id, rollup[p]);
+			//   }
+			// });
+			//
+			// Similarly, if "ab-cd" is requested, the algorithm can determine that "ab" is the best available and
+			// load accordingly.
+			//
+			// The builder will write such rollups for every layer if a non-empty localeList  profile property is
+			// provided. Further, the builder will include the following cache entry in the cache associated with
+			// any layer.
+			//
+			//   "*now":function(r){r(['dojo/i18n!*preload*<path>/nls/<module>*<JSON array of available locales>']);}
+			//
+			// The *now special cache module instructs the loader to apply the provided function to context-require
+			// with respect to the particular layer being defined. This causes the plugin to hold all normal service
+			// requests until all preloading is complete.
+			//
+			// Notice that this algorithm is rarely better than the standard AMD load algorithm. Consider the normal case
+			// where the target locale has a single segment and a layer depends on a single bundle:
+			//
+			// Without Preloads:
+			//
+			//   1. Layer loads root bundle.
+			//   2. bundle is demanded; plugin loads single localized bundle.
+			//
+			// With Preloads:
+			//
+			//   1. Layer causes preloading of target bundle.
+			//   2. bundle is demanded; service is delayed until preloading complete; bundle is returned.
+			//
+			// In each case a single transaction is required to load the target bundle. In cases where multiple bundles
+			// are required and/or the locale has multiple segments, preloads still requires a single transaction whereas
+			// the normal path requires an additional transaction for each additional bundle/locale-segment. However all
+			// of these additional transactions can be done concurrently. Owing to this analysis, the entire preloading
+			// algorithm can be discard during a build by setting the has feature dojo-preload-i18n-Api to false.
+			//
+			if(has("dojo-preload-i18n-Api")){
+				var split = id.split("*"),
+					preloadDemand = split[1]=="preload";
+				if(preloadDemand){
+					if(!cache[id]){
+						// use cache[id] to prevent multiple preloads of the same preload; this shouldn't happen, but
+						// who knows what over-aggressive human optimizers may attempt
+						cache[id] = 1;
+						preloadL10n(split[2], json.parse(split[3]), 1);
+					}
+					// don't stall the loader!
+					load(1);
+				}
+				if(preloadDemand || waitForPreloads(id, require, load)){
+					return;
+				}
+			}
+
+			var match= nlsRe.exec(id),
+				bundlePath= match[1] + "/",
+				bundleName= match[5] || match[4],
+				bundlePathAndName= bundlePath + bundleName,
+				localeSpecified = (match[5] && match[4]),
+				targetLocale=  localeSpecified || dojo.locale,
+				loadTarget= bundlePathAndName + "/" + targetLocale,
+				loadList = localeSpecified ? [targetLocale] : getLocalesToLoad(targetLocale),
+				remaining = loadList.length,
+				finish = function(){
+					if(!--remaining){
+						load(lang.delegate(cache[loadTarget]));
+					}
+				};
+			array.forEach(loadList, function(locale){
+				var target = bundlePathAndName + "/" + locale;
+				if(has("dojo-preload-i18n-Api")){
+					checkForLegacyModules(target);
+				}
+				if(!cache[target]){
+					doLoad(require, bundlePathAndName, bundlePath, bundleName, locale, finish);
+				}else{
+					finish();
+				}
+			});
+		};
+
+	if(has("dojo-unit-tests")){
+		var unitTests = thisModule.unitTests = [];
+	}
+
+	if(has("dojo-preload-i18n-Api") || 1){
+		var normalizeLocale = thisModule.normalizeLocale= function(locale){
+				var result = locale ? locale.toLowerCase() : dojo.locale;
+				return result == "root" ? "ROOT" : result;
+			},
+
+			isXd = function(mid){
+				return (1 && 1) ?
+					require.isXdUrl(require.toUrl(mid + ".js")) :
+					true;
+			},
+
+			preloading = 0,
+
+			preloadWaitQueue = [],
+
+			preloadL10n = thisModule._preloadLocalizations = function(/*String*/bundlePrefix, /*Array*/localesGenerated, /*boolean*/ guaranteedAmdFormat){
+				//	summary:
+				//		Load available flattened resource bundles associated with a particular module for dojo.locale and all dojo.config.extraLocale (if any)
+				//
+				//  descirption:
+				//		Only called by built layer files. The entire locale hierarchy is loaded. For example,
+				//		if locale=="ab-cd", then ROOT, "ab", and "ab-cd" are loaded. This is different than v1.6-
+				//		in that the v1.6- would lonly load ab-cd...which was *always* flattened.
+				//
+				//		If guaranteedAmdFormat is true, then the module can be loaded with require thereby circumventing the detection algorithm
+				//		and the extra possible extra transaction.
+				//
+
+				function forEachLocale(locale, func){
+					// given locale= "ab-cd-ef", calls func on "ab-cd-ef", "ab-cd", "ab", "ROOT"; stops calling the first time func returns truthy
+					var parts = locale.split("-");
+					while(parts.length){
+						if(func(parts.join("-"))){
+							return true;
+						}
+						parts.pop();
+					}
+					return func("ROOT");
+				}
+
+				function preload(locale){
+					locale = normalizeLocale(locale);
+					forEachLocale(locale, function(loc){
+						if(array.indexOf(localesGenerated, loc)>=0){
+							var mid = bundlePrefix.replace(/\./g, "/")+"_"+loc;
+							preloading++;
+							(isXd(mid) || guaranteedAmdFormat ? require : syncRequire)([mid], function(rollup){
+								for(var p in rollup){
+									cache[p + "/" + locale] = rollup[p];
+								}
+								--preloading;
+								while(!preloading && preloadWaitQueue.length){
+									load.apply(null, preloadWaitQueue.shift());
+								}
+							});
+							return true;
+						}
+						return false;
+					});
+				}
+
+				preload();
+				array.forEach(dojo.config.extraLocale, preload);
+			},
+
+			waitForPreloads = function(id, require, load){
+				if(preloading){
+					preloadWaitQueue.push([id, require, load]);
+				}
+				return preloading;
+			};
+	}
+
+	if(1){
+		// this code path assumes the dojo loader and won't work with a standard AMD loader
+		var evalBundle=
+				// use the function ctor to keep the minifiers away (also come close to global scope, but this is secondary)
+				new Function(
+					"__bundle",                // the bundle to evalutate
+					"__checkForLegacyModules", // a function that checks if __bundle defined __mid in the global space
+					"__mid",                   // the mid that __bundle is intended to define
+
+					// returns one of:
+					//		1 => the bundle was an AMD bundle
+					//		a legacy bundle object that is the value of __mid
+					//		instance of Error => could not figure out how to evaluate bundle
+
+					  // used to detect when __bundle calls define
+					  "var define = function(){define.called = 1;},"
+					+ "    require = function(){define.called = 1;};"
+
+					+ "try{"
+					+		"define.called = 0;"
+					+		"eval(__bundle);"
+					+		"if(define.called==1)"
+								// bundle called define; therefore signal it's an AMD bundle
+					+			"return 1;"
+
+					+		"if((__checkForLegacyModules = __checkForLegacyModules(__mid)))"
+								// bundle was probably a v1.6- built NLS flattened NLS bundle that defined __mid in the global space
+					+			"return __checkForLegacyModules;"
+
+					+ "}catch(e){}"
+					// evaulating the bundle was *neither* an AMD *nor* a legacy flattened bundle
+					// either way, re-eval *after* surrounding with parentheses
+
+					+ "try{"
+					+ 		"return eval('('+__bundle+')');"
+					+ "}catch(e){"
+					+ 		"return e;"
+					+ "}"
+				),
+
+			syncRequire= function(deps, callback){
+				var results= [];
+				array.forEach(deps, function(mid){
+					var url= require.toUrl(mid + ".js");
+
+					function load(text){
+						var result = evalBundle(text, checkForLegacyModules, mid);
+						if(result===1){
+							// the bundle was an AMD module; re-inject it through the normal AMD path
+							// we gotta do this since it could be an anonymous module and simply evaluating
+							// the text here won't provide the loader with the context to know what
+							// module is being defined()'d. With browser caching, this should be free; further
+							// this entire code path can be circumvented by using the AMD format to begin with
+							require([mid], function(bundle){
+								results.push(cache[url]= bundle);
+							});
+						}else{
+							if(result instanceof Error){
+								console.error("failed to evaluate i18n bundle; url=" + url, result);
+								result = {};
+							}
+							// nls/<locale>/<bundle-name> indicates not the root.
+							results.push(cache[url] = (/nls\/[^\/]+\/[^\/]+$/.test(url) ? result : {root:result, _v1x:1}));
+						}
+					}
+
+					if(cache[url]){
+						results.push(cache[url]);
+					}else{
+						var bundle= require.syncLoadNls(mid);
+						// don't need to check for legacy since syncLoadNls returns a module if the module
+						// (1) was already loaded, or (2) was in the cache. In case 1, if syncRequire is called
+						// from getLocalization --> load, then load will have called checkForLegacyModules() before
+						// calling syncRequire; if syncRequire is called from preloadLocalizations, then we
+						// don't care about checkForLegacyModules() because that will be done when a particular
+						// bundle is actually demanded. In case 2, checkForLegacyModules() is never relevant
+						// because cached modules are always v1.7+ built modules.
+						if(bundle){
+							results.push(bundle);
+						}else{
+							if(!xhr){
+								try{
+									require.getText(url, true, load);
+								}catch(e){
+									results.push(cache[url]= {});
+								}
+							}else{
+								xhr.get({
+									url:url,
+									sync:true,
+									load:load,
+									error:function(){
+										results.push(cache[url]= {});
+									}
+								});
+							}
+						}
+					}
+				});
+				callback && callback.apply(null, results);
+			},
+
+			checkForLegacyModules = function(target){
+				// legacy code may have already loaded [e.g] the raw bundle x/y/z at x.y.z; when true, push into the cache
+				for(var result, names = target.split("/"), object = dojo.global[names[0]], i = 1; object && i<names.length-1; object = object[names[i++]]){}
+				if(object){
+					result = object[names[i]];
+					if(!result){
+						// fallback for incorrect bundle build of 1.6
+						result = object[names[i].replace(/-/g,"_")];
+					}
+					if(result){
+						cache[target] = result;
+					}
+				}
+				return result;
+			};
+
+		thisModule.getLocalization= function(moduleName, bundleName, locale){
+			var result,
+				l10nName= getL10nName(moduleName, bundleName, locale).substring(10);
+			load(l10nName, (!isXd(l10nName) ? syncRequire : require), function(result_){ result= result_; });
+			return result;
+		};
+
+		if(has("dojo-unit-tests")){
+			unitTests.push(function(doh){
+				doh.register("tests.i18n.unit", function(t){
+					var check;
+
+					check = evalBundle("{prop:1}");
+					t.is({prop:1}, check); t.is(undefined, check[1]);
+
+					check = evalBundle("({prop:1})");
+					t.is({prop:1}, check); t.is(undefined, check[1]);
+
+					check = evalBundle("{'prop-x':1}");
+					t.is({'prop-x':1}, check); t.is(undefined, check[1]);
+
+					check = evalBundle("({'prop-x':1})");
+					t.is({'prop-x':1}, check); t.is(undefined, check[1]);
+
+					check = evalBundle("define({'prop-x':1})");
+					t.is(1, check);
+
+					check = evalBundle("this is total nonsense and should throw an error");
+					t.is(check instanceof Error, true);
+				});
+			});
+		}
+	}
+
+	return lang.mixin(thisModule, {
+		dynamic:true,
+		normalize:normalize,
+		load:load,
+		cache:cache
+	});
+});