text: //>>built
  define("dojo/_base/config", ["../has", "require"], function(has, require){
  	// module:
  	//		dojo/_base/config
  	// summary:
  	//		This module defines the user configuration during bootstrap.
  	// description:
  	//		By defining user configuration as a module value, an entire configuration can be specified in a build,
      //		thereby eliminating the need for sniffing and or explicitly setting in the global variable dojoConfig.
      //		Also, when multiple instances of dojo exist in a single application, each will necessarily be located
  	//		at an unique absolute module identifier as given by the package configuration. Implementing configuration
  	//		as a module allows for specifying unique, per-instance configurations.
  	// example:
  	//		Create a second instance of dojo with a different, instance-uniqe configuration (assume the loader and
  	//		dojo.js are already loaded).
  	//		|	// specify a configuration that creates a new instance of dojo at the absolute module identifier "myDojo"
  	//		|	require({
  	//		|		packages:[{
  	//		|			name:"myDojo",
  	//		|			location:".", //assume baseUrl points to dojo.js
  	//		|	    }]
  	//		|	});
  	//		|
  	//		|	// specify a configuration for the myDojo instance
  	//		|	define("myDojo/config", {
  	//		|		// normal configuration variables go here, e.g.,
  	//		|		locale:"fr-ca"
  	//		|	});
  	//		|
  	//		|	// load and use the new instance of dojo
  	//		|	require(["myDojo"], function(dojo) {
  	//		|		// dojo is the new instance of dojo
  	//		|		// use as required
  	//		|	});
  
  	var result = {};
  	if(1){
  		// must be the dojo loader; take a shallow copy of require.rawConfig
  		var src = require.rawConfig, p;
  		for(p in src){
  			result[p] = src[p];
  		}
  	}else{
  		var adviseHas = function(featureSet, prefix, booting){
  			for(p in featureSet){
  				p!="has" && has.add(prefix + p, featureSet[p], 0, booting);
  			}
  		};
  		result = 1 ?
  			// must be a built version of the dojo loader; all config stuffed in require.rawConfig
  			require.rawConfig :
  			// a foreign loader
  			this.dojoConfig || this.djConfig || {};
  		adviseHas(result, "config", 1);
  		adviseHas(result.has, "", 1);
  	}
  	return result;
  
  /*=====
  // note:
  //		'dojoConfig' does not exist under 'dojo.*' so that it can be set before the
  //		'dojo' variable exists.
  // note:
  //		Setting any of these variables *after* the library has loaded does
  //		nothing at all.
  
  // FIXME: can we document these on dojo.config object and explain they must be set via djConfig/dojoConfig global prior to loading dojo.js
  
  dojoConfig = {
  	// summary:
  	//		Application code can set the global 'dojoConfig' prior to loading
  	//		the library to control certain global settings for how dojo works.
  	//
  	// isDebug: Boolean
  	//		Defaults to `false`. If set to `true`, ensures that Dojo provides
  	//		extended debugging feedback via Firebug. If Firebug is not available
  	//		on your platform, setting `isDebug` to `true` will force Dojo to
  	//		pull in (and display) the version of Firebug Lite which is
  	//		integrated into the Dojo distribution, thereby always providing a
  	//		debugging/logging console when `isDebug` is enabled. Note that
  	//		Firebug's `console.*` methods are ALWAYS defined by Dojo. If
  	//		`isDebug` is false and you are on a platform without Firebug, these
  	//		methods will be defined as no-ops.
  	isDebug: false,
  	// locale: String
  	//		The locale to assume for loading localized resources in this page,
  	//		specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
  	//		Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`.
  	//		See the documentation for `dojo.i18n` and `dojo.requireLocalization`
  	//		for details on loading localized resources. If no locale is specified,
  	//		Dojo assumes the locale of the user agent, according to `navigator.userLanguage`
  	//		or `navigator.language` properties.
  	locale: undefined,
  	// extraLocale: Array
  	//		No default value. Specifies additional locales whose
  	//		resources should also be loaded alongside the default locale when
  	//		calls to `dojo.requireLocalization()` are processed.
  	extraLocale: undefined,
  	// baseUrl: String
  	//		The directory in which `dojo.js` is located. Under normal
  	//		conditions, Dojo auto-detects the correct location from which it
  	//		was loaded. You may need to manually configure `baseUrl` in cases
  	//		where you have renamed `dojo.js` or in which `<base>` tags confuse
  	//		some browsers (e.g. IE 6). The variable `dojo.baseUrl` is assigned
  	//		either the value of `djConfig.baseUrl` if one is provided or the
  	//		auto-detected root if not. Other modules are located relative to
  	//		this path. The path should end in a slash.
  	baseUrl: undefined,
  	// modulePaths: Object
  	//		A map of module names to paths relative to `dojo.baseUrl`. The
  	//		key/value pairs correspond directly to the arguments which
  	//		`dojo.registerModulePath` accepts. Specifiying
  	//		`djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent
  	//		of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple
  	//		modules may be configured via `djConfig.modulePaths`.
  	modulePaths: {},
  	// afterOnLoad: Boolean
  	//		Indicates Dojo was added to the page after the page load. In this case
  	//		Dojo will not wait for the page DOMContentLoad/load events and fire
  	//		its dojo.addOnLoad callbacks after making sure all outstanding
  	//		dojo.required modules have loaded. Only works with a built dojo.js,
  	//		it does not work the dojo.js directly from source control.
  	afterOnLoad: false,
  	// addOnLoad: Function or Array
  	//		Adds a callback via dojo.addOnLoad. Useful when Dojo is added after
  	//		the page loads and djConfig.afterOnLoad is true. Supports the same
  	//		arguments as dojo.addOnLoad. When using a function reference, use
  	//		`djConfig.addOnLoad = function(){};`. For object with function name use
  	//		`djConfig.addOnLoad = [myObject, "functionName"];` and for object with
  	//		function reference use
  	//		`djConfig.addOnLoad = [myObject, function(){}];`
  	addOnLoad: null,
  	// require: Array
  	//		An array of module names to be loaded immediately after dojo.js has been included
  	//		in a page.
  	require: [],
  	// defaultDuration: Array
  	//		Default duration, in milliseconds, for wipe and fade animations within dijits.
  	//		Assigned to dijit.defaultDuration.
  	defaultDuration: 200,
  	// dojoBlankHtmlUrl: String
  	//		Used by some modules to configure an empty iframe. Used by dojo.io.iframe and
  	//		dojo.back, and dijit popup support in IE where an iframe is needed to make sure native
  	//		controls do not bleed through the popups. Normally this configuration variable
  	//		does not need to be set, except when using cross-domain/CDN Dojo builds.
  	//		Save dojo/resources/blank.html to your domain and set `djConfig.dojoBlankHtmlUrl`
  	//		to the path on your domain your copy of blank.html.
  	dojoBlankHtmlUrl: undefined,
  	//	ioPublish: Boolean?
  	//		Set this to true to enable publishing of topics for the different phases of
  	//		IO operations. Publishing is done via dojo.publish. See dojo.__IoPublish for a list
  	//		of topics that are published.
  	ioPublish: false,
  	//	useCustomLogger: Anything?
  	//		If set to a value that evaluates to true such as a string or array and
  	//		isDebug is true and Firebug is not available or running, then it bypasses
  	//		the creation of Firebug Lite allowing you to define your own console object.
  	useCustomLogger: undefined,
  	// transparentColor: Array
  	//		Array containing the r, g, b components used as transparent color in dojo.Color;
  	//		if undefined, [255,255,255] (white) will be used.
  	transparentColor: undefined,
  	// skipIeDomLoaded: Boolean
  	//		For IE only, skip the DOMContentLoaded hack used. Sometimes it can cause an Operation
  	//		Aborted error if the rest of the page triggers script defers before the DOM is ready.
  	//		If this is config value is set to true, then dojo.addOnLoad callbacks will not be
  	//		triggered until the page load event, which is after images and iframes load. If you
  	//		want to trigger the callbacks sooner, you can put a script block in the bottom of
  	//		your HTML that calls dojo._loadInit();. If you are using multiversion support, change
  	//		"dojo." to the appropriate scope name for dojo.
  	skipIeDomLoaded: false
  }
  =====*/
  });
  
   