text: /*
  	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
  */
  
  
  if(!dojo._hasResource["dojo.i18n"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
  dojo._hasResource["dojo.i18n"] = true;
  dojo.provide("dojo.i18n");
  
  
  dojo.getObject("i18n", true, dojo);
  
  /*=====
  dojo.i18n = {
  	// summary: Utility classes to enable loading of resources for internationalization (i18n)
  };
  =====*/
  
  // when using a real AMD loader, dojo.i18n.getLocalization is already defined by dojo/lib/backCompat
  dojo.i18n.getLocalization = dojo.i18n.getLocalization || function(/*String*/packageName, /*String*/bundleName, /*String?*/locale){
  	//	summary:
  	//		Returns an Object containing the localization for a given resource
  	//		bundle in a package, matching the specified locale.
  	//	description:
  	//		Returns a hash containing name/value pairs in its prototypesuch
  	//		that values can be easily overridden.  Throws an exception if the
  	//		bundle is not found.  Bundle must have already been loaded by
  	//		`dojo.requireLocalization()` or by a build optimization step.  NOTE:
  	//		try not to call this method as part of an object property
  	//		definition (`var foo = { bar: dojo.i18n.getLocalization() }`).  In
  	//		some loading situations, the bundle may not be available in time
  	//		for the object definition.  Instead, call this method inside a
  	//		function that is run after all modules load or the page loads (like
  	//		in `dojo.addOnLoad()`), or in a widget lifecycle method.
  	//	packageName:
  	//		package which is associated with this resource
  	//	bundleName:
  	//		the base filename of the resource bundle (without the ".js" suffix)
  	//	locale:
  	//		the variant to load (optional).  By default, the locale defined by
  	//		the host environment: dojo.locale
  
  	locale = dojo.i18n.normalizeLocale(locale);
  
  	// look for nearest locale match
  	var elements = locale.split('-');
  	var module = [packageName,"nls",bundleName].join('.');
  		var bundle = dojo._loadedModules[module];
  	if(bundle){
  		var localization;
  		for(var i = elements.length; i > 0; i--){
  			var loc = elements.slice(0, i).join('_');
  			if(bundle[loc]){
  				localization = bundle[loc];
  				break;
  			}
  		}
  		if(!localization){
  			localization = bundle.ROOT;
  		}
  
  		// make a singleton prototype so that the caller won't accidentally change the values globally
  		if(localization){
  			var clazz = function(){};
  			clazz.prototype = localization;
  			return new clazz(); // Object
  		}
  	}
  
  	throw new Error("Bundle not found: " + bundleName + " in " + packageName+" , locale=" + locale);
  };
  
  dojo.i18n.normalizeLocale = function(/*String?*/locale){
  	//	summary:
  	//		Returns canonical form of locale, as used by Dojo.
  	//
  	//  description:
  	//		All variants are case-insensitive and are separated by '-' as specified in [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
  	//		If no locale is specified, the dojo.locale is returned.  dojo.locale is defined by
  	//		the user agent's locale unless overridden by djConfig.
  
  	var result = locale ? locale.toLowerCase() : dojo.locale;
  	if(result == "root"){
  		result = "ROOT";
  	}
  	return result; // String
  };
  
  dojo.i18n._requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String?*/availableFlatLocales){
  	//	summary:
  	//		See dojo.requireLocalization()
  	//	description:
  	// 		Called by the bootstrap, but factored out so that it is only
  	// 		included in the build when needed.
  
  	var targetLocale = dojo.i18n.normalizeLocale(locale);
   	var bundlePackage = [moduleName, "nls", bundleName].join(".");
  	// NOTE:
  	//		When loading these resources, the packaging does not match what is
  	//		on disk.  This is an implementation detail, as this is just a
  	//		private data structure to hold the loaded resources.  e.g.
  	//		`tests/hello/nls/en-us/salutations.js` is loaded as the object
  	//		`tests.hello.nls.salutations.en_us={...}` The structure on disk is
  	//		intended to be most convenient for developers and translators, but
  	//		in memory it is more logical and efficient to store in a different
  	//		order.  Locales cannot use dashes, since the resulting path will
  	//		not evaluate as valid JS, so we translate them to underscores.
  
  	//Find the best-match locale to load if we have available flat locales.
  	var bestLocale = "";
  	if(availableFlatLocales){
  		var flatLocales = availableFlatLocales.split(",");
  		for(var i = 0; i < flatLocales.length; i++){
  			//Locale must match from start of string.
  			//Using ["indexOf"] so customBase builds do not see
  			//this as a dojo._base.array dependency.
  			if(targetLocale["indexOf"](flatLocales[i]) == 0){
  				if(flatLocales[i].length > bestLocale.length){
  					bestLocale = flatLocales[i];
  				}
  			}
  		}
  		if(!bestLocale){
  			bestLocale = "ROOT";
  		}
  	}
  
  	//See if the desired locale is already loaded.
  	var tempLocale = availableFlatLocales ? bestLocale : targetLocale;
  	var bundle = dojo._loadedModules[bundlePackage];
  	var localizedBundle = null;
  	if(bundle){
  		if(dojo.config.localizationComplete && bundle._built){return;}
  		var jsLoc = tempLocale.replace(/-/g, '_');
  		var translationPackage = bundlePackage+"."+jsLoc;
  		localizedBundle = dojo._loadedModules[translationPackage];
  	}
  
  	if(!localizedBundle){
  		bundle = dojo["provide"](bundlePackage);
  		var syms = dojo._getModuleSymbols(moduleName);
  		var modpath = syms.concat("nls").join("/");
  		var parent;
  
  		dojo.i18n._searchLocalePath(tempLocale, availableFlatLocales, function(loc){
  			var jsLoc = loc.replace(/-/g, '_');
  			var translationPackage = bundlePackage + "." + jsLoc;
  			var loaded = false;
  			if(!dojo._loadedModules[translationPackage]){
  				// Mark loaded whether it's found or not, so that further load attempts will not be made
  				dojo["provide"](translationPackage);
  				var module = [modpath];
  				if(loc != "ROOT"){module.push(loc);}
  				module.push(bundleName);
  				var filespec = module.join("/") + '.js';
  				loaded = dojo._loadPath(filespec, null, function(hash){
  					hash = hash.root || hash;
  					// Use singleton with prototype to point to parent bundle, then mix-in result from loadPath
  					var clazz = function(){};
  					clazz.prototype = parent;
  					bundle[jsLoc] = new clazz();
  					for(var j in hash){ bundle[jsLoc][j] = hash[j]; }
  				});
  			}else{
  				loaded = true;
  			}
  			if(loaded && bundle[jsLoc]){
  				parent = bundle[jsLoc];
  			}else{
  				bundle[jsLoc] = parent;
  			}
  
  			if(availableFlatLocales){
  				//Stop the locale path searching if we know the availableFlatLocales, since
  				//the first call to this function will load the only bundle that is needed.
  				return true;
  			}
  		});
  	}
  
  	//Save the best locale bundle as the target locale bundle when we know the
  	//the available bundles.
  	if(availableFlatLocales && targetLocale != bestLocale){
  		bundle[targetLocale.replace(/-/g, '_')] = bundle[bestLocale.replace(/-/g, '_')];
  	}
  };
  
  (function(){
  	// If other locales are used, dojo.requireLocalization should load them as
  	// well, by default.
  	//
  	// Override dojo.requireLocalization to do load the default bundle, then
  	// iterate through the extraLocale list and load those translations as
  	// well, unless a particular locale was requested.
  
  	var extra = dojo.config.extraLocale;
  	if(extra){
  		if(!extra instanceof Array){
  			extra = [extra];
  		}
  
  		var req = dojo.i18n._requireLocalization;
  		dojo.i18n._requireLocalization = function(m, b, locale, availableFlatLocales){
  			req(m,b,locale, availableFlatLocales);
  			if(locale){return;}
  			for(var i=0; i<extra.length; i++){
  				req(m,b,extra[i], availableFlatLocales);
  			}
  		};
  	}
  })();
  
  dojo.i18n._searchLocalePath = function(/*String*/locale, /*Boolean*/down, /*Function*/searchFunc){
  	//	summary:
  	//		A helper method to assist in searching for locale-based resources.
  	//		Will iterate through the variants of a particular locale, either up
  	//		or down, executing a callback function.  For example, "en-us" and
  	//		true will try "en-us" followed by "en" and finally "ROOT".
  
  	locale = dojo.i18n.normalizeLocale(locale);
  
  	var elements = locale.split('-');
  	var searchlist = [];
  	for(var i = elements.length; i > 0; i--){
  		searchlist.push(elements.slice(0, i).join('-'));
  	}
  	searchlist.push(false);
  	if(down){searchlist.reverse();}
  
  	for(var j = searchlist.length - 1; j >= 0; j--){
  		var loc = searchlist[j] || "ROOT";
  		var stop = searchFunc(loc);
  		if(stop){ break; }
  	}
  };
  
  dojo.i18n._preloadLocalizations = function(/*String*/bundlePrefix, /*Array*/localesGenerated){
  	//	summary:
  	//		Load built, flattened resource bundles, if available for all
  	//		locales used in the page. Only called by built layer files.
  
  	function preload(locale){
  		locale = dojo.i18n.normalizeLocale(locale);
  		dojo.i18n._searchLocalePath(locale, true, function(loc){
  			for(var i=0; i<localesGenerated.length;i++){
  				if(localesGenerated[i] == loc){
  					dojo["require"](bundlePrefix+"_"+loc);
  					return true; // Boolean
  				}
  			}
  			return false; // Boolean
  		});
  	}
  	preload();
  	var extra = dojo.config.extraLocale||[];
  	for(var i=0; i<extra.length; i++){
  		preload(extra[i]);
  	}
  };
  
  }
  