dojo-rails 0.9.9 → 0.9.10

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

@@ -1,31 +1,31 @@
-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) {
+define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_base/config", "./_base/lang", "./_base/xhr", "./json", "module"],
+	function(dojo, require, has, array, config, lang, xhr, json, module){
+
 	// 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",
+	 1 || has.add("dojo-v1x-i18n-Api",
 		// if true, define the v1.x i18n functions
 		1
 	);
 
 	var
-		thisModule= dojo.i18n=
-			// the dojo.i18n module
-			{},
+		thisModule = 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.
+			},
 
-		nlsRe=
+		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"]
@@ -35,27 +35,31 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 			// courtesy of http://requirejs.org
 			/(^.*(^|\/)nls)(\/|$)([^\/]*)\/?([^\/]*)/,
 
-		getAvailableLocales= function(
+		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.
+			// summary:
+			//		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
 			//
-			// 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
+			//			["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];
+			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);
 				}
@@ -63,38 +67,44 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 			return result;
 		},
 
-		cache= {},
+		cache = {},
 
-		getL10nName= dojo.getL10nName = function(moduleName, bundleName, locale){
+		getBundleName = function(moduleName, bundleName, locale){
 			locale = locale ? locale.toLowerCase() : dojo.locale;
-			moduleName = "dojo/i18n!" + moduleName.replace(/\./g, "/");
+			moduleName = moduleName.replace(/\./g, "/");
 			bundleName = bundleName.replace(/\./g, "/");
 			return (/root/i.test(locale)) ?
 				(moduleName + "/nls/" + bundleName) :
 				(moduleName + "/nls/" + locale + "/" + bundleName);
 		},
 
+		getL10nName = dojo.getL10nName = function(moduleName, bundleName, locale){
+			return moduleName = module.id + "!" + getBundleName(moduleName, bundleName, locale);
+		},
+
 		doLoad = function(require, bundlePathAndName, bundlePath, bundleName, locale, load){
-			// get the root bundle which instructs which other bundles are required to construct the localized bundle
+			// summary:
+			//		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);
+				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]);
+					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;
+					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
+			// summary:
+			//		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;
 		},
 
@@ -106,139 +116,139 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 		},
 
 		load = function(id, require, load){
+			// summary:
+			//		id is in one of the following formats
 			//
-			// 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.
+			//		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>
+			//		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
+			//		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.
+			//		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 absolute; 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
+			//		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>
+			//			<path>/nls/<bundle>/<locale>
 			//
-			// will hold the value. Similarly, then plugin will publish this value to the loader by
+			//		will hold the value. Similarly, then plugin will publish this value to the loader by
 			//
-			//   define("<path>/nls/<bundle>/<locale>", <bundle-value>);
+			//			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.
+			//		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:
+			//		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
+			//		1. The client demands "dojo/i18n!some/path/nls/someBundle
 			//
-			// 2. The loader demands load(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.
+			//		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"
+			//		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...
+			//		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"));
+			//				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.
+			//		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 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:
+			//		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"]
+			//			*preload*some/path/nls/someModule*["root", "ab", "ab-cd-ef"]
 			//
-			// This indicates the following rollup modules are available:
+			//		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
+			//			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:
+			//		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 follows:
 			//
-			// 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>,
-			// });
+			//			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:
+			//		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]);
-			//   }
-			// });
+			//			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.
+			//		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.
+			//		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>']);}
+			//			"*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.
+			//		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:
+			//		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:
+			//		Without Preloads:
 			//
-			//   1. Layer loads root bundle.
-			//   2. bundle is demanded; plugin loads single localized bundle.
+			//		1. Layer loads root bundle.
+			//		2. bundle is demanded; plugin loads single localized bundle.
 			//
-			// With Preloads:
+			//		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.
+			//		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";
+					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);
+						preloadL10n(split[2], json.parse(split[3]), 1, require);
 					}
 					// don't stall the loader!
 					load(1);
@@ -248,13 +258,13 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 				}
 			}
 
-			var match= nlsRe.exec(id),
-				bundlePath= match[1] + "/",
-				bundleName= match[5] || match[4],
-				bundlePathAndName= bundlePath + bundleName,
+			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,
+				targetLocale =	localeSpecified || dojo.locale,
+				loadTarget = bundlePathAndName + "/" + targetLocale,
 				loadList = localeSpecified ? [targetLocale] : getLocalesToLoad(targetLocale),
 				remaining = loadList.length,
 				finish = function(){
@@ -279,15 +289,15 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 		var unitTests = thisModule.unitTests = [];
 	}
 
-	if(has("dojo-preload-i18n-Api") || 1){
-		var normalizeLocale = thisModule.normalizeLocale= function(locale){
+	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")) :
+			isXd = function(mid, contextRequire){
+				return ( 1  &&  1 ) ?
+					contextRequire.isXdUrl(require.toUrl(mid + ".js")) :
 					true;
 			},
 
@@ -295,29 +305,40 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 
 			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:
+			preloadL10n = thisModule._preloadLocalizations = function(/*String*/bundlePrefix, /*Array*/localesGenerated, /*boolean?*/ guaranteedAmdFormat, /*function?*/ contextRequire){
+				// summary:
+				//		Load available flattened resource bundles associated with a particular module for dojo/locale and all dojo/config.extraLocale (if any)
+				// description:
 				//		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.
+				//		in that the v1.6- would only 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.
-				//
+
+				// If this function is called from legacy code, then guaranteedAmdFormat and contextRequire will be undefined. Since the function
+				// needs a require in order to resolve module ids, fall back to the context-require associated with this dojo/i18n module, which
+				// itself may have been mapped.
+				contextRequire = contextRequire || require;
+
+				function doRequire(mid, callback){
+					if(isXd(mid, contextRequire) || guaranteedAmdFormat){
+						contextRequire([mid], callback);
+					}else{
+						syncRequire([mid], callback, contextRequire);
+					}
+				}
 
 				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;
+							return;
 						}
 						parts.pop();
 					}
-					return func("ROOT");
+					func("ROOT");
 				}
 
 				function preload(locale){
@@ -326,9 +347,9 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 						if(array.indexOf(localesGenerated, loc)>=0){
 							var mid = bundlePrefix.replace(/\./g, "/")+"_"+loc;
 							preloading++;
-							(isXd(mid) || guaranteedAmdFormat ? require : syncRequire)([mid], function(rollup){
+							doRequire(mid, function(rollup){
 								for(var p in rollup){
-									cache[p + "/" + locale] = rollup[p];
+									cache[require.toAbsMid(p) + "/" + loc] = rollup[p];
 								}
 								--preloading;
 								while(!preloading && preloadWaitQueue.length){
@@ -350,17 +371,22 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 					preloadWaitQueue.push([id, require, load]);
 				}
 				return preloading;
-			};
+			},
+
+			checkForLegacyModules = function()
+				{};
 	}
 
-	if(1){
+	if( 1 ){
 		// this code path assumes the dojo loader and won't work with a standard AMD loader
-		var evalBundle=
+		var amdValue = {},
+			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
+					"__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
+					"__mid",				   // the mid that __bundle is intended to define
+					"__amdValue",
 
 					// returns one of:
 					//		1 => the bundle was an AMD bundle
@@ -368,15 +394,15 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 					//		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;};"
+					  "var define = function(mid, factory){define.called = 1; __amdValue.result = factory || mid;},"
+					+ "	   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;"
+					+			"return __amdValue;"
 
 					+		"if((__checkForLegacyModules = __checkForLegacyModules(__mid)))"
 								// bundle was probably a v1.6- built NLS flattened NLS bundle that defined __mid in the global space
@@ -387,28 +413,26 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 					// either way, re-eval *after* surrounding with parentheses
 
 					+ "try{"
-					+ 		"return eval('('+__bundle+')');"
+					+		"return eval('('+__bundle+')');"
 					+ "}catch(e){"
-					+ 		"return e;"
+					+		"return e;"
 					+ "}"
 				),
 
-			syncRequire= function(deps, callback){
-				var results= [];
+			syncRequire = function(deps, callback, require){
+				var results = [];
 				array.forEach(deps, function(mid){
-					var url= require.toUrl(mid + ".js");
+					var url = require.toUrl(mid + ".js");
 
 					function load(text){
-						var result = evalBundle(text, checkForLegacyModules, mid);
-						if(result===1){
+						var result = evalBundle(text, checkForLegacyModules, mid, amdValue);
+						if(result===amdValue){
 							// 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);
-							});
+							results.push(cache[url] = amdValue.result);
 						}else{
 							if(result instanceof Error){
 								console.error("failed to evaluate i18n bundle; url=" + url, result);
@@ -422,7 +446,7 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 					if(cache[url]){
 						results.push(cache[url]);
 					}else{
-						var bundle= require.syncLoadNls(mid);
+						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
@@ -437,7 +461,7 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 								try{
 									require.getText(url, true, load);
 								}catch(e){
-									results.push(cache[url]= {});
+									results.push(cache[url] = {});
 								}
 							}else{
 								xhr.get({
@@ -445,7 +469,7 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 									sync:true,
 									load:load,
 									error:function(){
-										results.push(cache[url]= {});
+										results.push(cache[url] = {});
 									}
 								});
 							}
@@ -453,28 +477,37 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 					}
 				});
 				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;
-					}
+		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,"_")];
 				}
-				return result;
-			};
+				if(result){
+					cache[target] = result;
+				}
+			}
+			return result;
+		};
 
-		thisModule.getLocalization= function(moduleName, bundleName, locale){
+		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_; });
+				l10nName = getBundleName(moduleName, bundleName, locale);
+			load(
+				l10nName,
+
+				// isXd() and syncRequire() need a context-require in order to resolve the mid with respect to a reference module.
+				// Since this legacy function does not have the concept of a reference module, resolve with respect to this
+				// dojo/i18n module, which, itself may have been mapped.
+				(!isXd(l10nName, require) ? function(deps, callback){ syncRequire(deps, callback, require); } : require),
+
+				function(result_){ result = result_; }
+			);
 			return result;
 		};
 
@@ -483,22 +516,25 @@ define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_
 				doh.register("tests.i18n.unit", function(t){
 					var check;
 
-					check = evalBundle("{prop:1}");
+					check = evalBundle("{prop:1}", checkForLegacyModules, "nonsense", amdValue);
 					t.is({prop:1}, check); t.is(undefined, check[1]);
 
-					check = evalBundle("({prop:1})");
+					check = evalBundle("({prop:1})", checkForLegacyModules, "nonsense", amdValue);
 					t.is({prop:1}, check); t.is(undefined, check[1]);
 
-					check = evalBundle("{'prop-x':1}");
+					check = evalBundle("{'prop-x':1}", checkForLegacyModules, "nonsense", amdValue);
 					t.is({'prop-x':1}, check); t.is(undefined, check[1]);
 
-					check = evalBundle("({'prop-x':1})");
+					check = evalBundle("({'prop-x':1})", checkForLegacyModules, "nonsense", amdValue);
 					t.is({'prop-x':1}, check); t.is(undefined, check[1]);
 
-					check = evalBundle("define({'prop-x':1})");
-					t.is(1, check);
+					check = evalBundle("define({'prop-x':1})", checkForLegacyModules, "nonsense", amdValue);
+					t.is(amdValue, check); t.is({'prop-x':1}, amdValue.result);
+
+					check = evalBundle("define('some/module', {'prop-x':1})", checkForLegacyModules, "nonsense", amdValue);
+					t.is(amdValue, check); t.is({'prop-x':1}, amdValue.result);
 
-					check = evalBundle("this is total nonsense and should throw an error");
+					check = evalBundle("this is total nonsense and should throw an error", checkForLegacyModules, "nonsense", amdValue);
 					t.is(check instanceof Error, true);
 				});
 			});