text: define("dojo/_base/kernel", ["../has", "./config", "require", "module"], function(has, config, require, module){
  	// module:
  	//		dojo/_base/kernel
  
  	// This module is the foundational module of the dojo boot sequence; it defines the dojo object.
  
  	var
  		// loop variables for this module
  		i, p,
  
  		// create dojo, dijit, and dojox
  		// FIXME: in 2.0 remove dijit, dojox being created by dojo
  		dijit = {},
  		dojox = {},
  		dojo = {
  			// summary:
  			//		This module is the foundational module of the dojo boot sequence; it defines the dojo object.
  
  			// notice dojo takes ownership of the value of the config module
  			config:config,
  			global:this,
  			dijit:dijit,
  			dojox:dojox
  		};
  
  
  	// Configure the scope map. For a 100% AMD application, the scope map is not needed other than to provide
  	// a _scopeName property for the dojo, dijit, and dojox root object so those packages can create
  	// unique names in the global space.
  	//
  	// Built, legacy modules use the scope map to allow those modules to be expressed as if dojo, dijit, and dojox,
  	// where global when in fact they are either global under different names or not global at all. In v1.6-, the
  	// config variable "scopeMap" was used to map names as used within a module to global names. This has been
  	// subsumed by the AMD map configuration variable which can relocate packages to different names. For backcompat,
  	// only the "*" mapping is supported. See http://livedocs.dojotoolkit.org/developer/design/loader#legacy-cross-domain-mode for details.
  	//
  	// The following computations contort the packageMap for this dojo instance into a scopeMap.
  	var scopeMap =
  			// a map from a name used in a legacy module to the (global variable name, object addressed by that name)
  			// always map dojo, dijit, and dojox
  			{
  				dojo:["dojo", dojo],
  				dijit:["dijit", dijit],
  				dojox:["dojox", dojox]
  			},
  
  		packageMap =
  			// the package map for this dojo instance; note, a foreign loader or no pacakgeMap results in the above default config
  			(require.map && require.map[module.id.match(/[^\/]+/)[0]]),
  
  		item;
  
  
  	// process all mapped top-level names for this instance of dojo
  	for(p in packageMap){
  		if(scopeMap[p]){
  			// mapped dojo, dijit, or dojox
  			scopeMap[p][0] = packageMap[p];
  		}else{
  			// some other top-level name
  			scopeMap[p] = [packageMap[p], {}];
  		}
  	}
  
  	// publish those names to _scopeName and, optionally, the global namespace
  	for(p in scopeMap){
  		item = scopeMap[p];
  		item[1]._scopeName = item[0];
  		if(!config.noGlobals){
  			this[item[0]] = item[1];
  		}
  	}
  	dojo.scopeMap = scopeMap;
  
  	/*===== dojo.__docParserConfigureScopeMap(scopeMap); =====*/
  
  	// FIXME: dojo.baseUrl and dojo.config.baseUrl should be deprecated
  	dojo.baseUrl = dojo.config.baseUrl = require.baseUrl;
  	dojo.isAsync = ! 1  || require.async;
  	dojo.locale = config.locale;
  
  	var rev = "$Rev$".match(/[0-9a-f]{7,}/);
  	dojo.version = {
  		// summary:
  		//		Version number of the Dojo Toolkit
  		// description:
  		//		Hash about the version, including
  		//
  		//		- major: Integer: Major version. If total version is "1.2.0beta1", will be 1
  		//		- minor: Integer: Minor version. If total version is "1.2.0beta1", will be 2
  		//		- patch: Integer: Patch version. If total version is "1.2.0beta1", will be 0
  		//		- flag: String: Descriptor flag. If total version is "1.2.0beta1", will be "beta1"
  		//		- revision: Number: The Git rev from which dojo was pulled
  
  		major: 1, minor: 10, patch: 0, flag: "-pre",
  		revision: rev ? rev[0] : NaN,
  		toString: function(){
  			var v = dojo.version;
  			return v.major + "." + v.minor + "." + v.patch + v.flag + " (" + v.revision + ")";	// String
  		}
  	};
  
  	// If  1  is truthy, then as a dojo module is defined it should push it's definitions
  	// into the dojo object, and conversely. In 2.0, it will likely be unusual to augment another object
  	// as a result of defining a module. This has feature gives a way to force 2.0 behavior as the code
  	// is migrated. Absent specific advice otherwise, set extend-dojo to truthy.
  	 1 || has.add("extend-dojo", 1);
  
  
  	(Function("d", "d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo);
  	/*=====
  	dojo.eval = function(scriptText){
  		// summary:
  		//		A legacy method created for use exclusively by internal Dojo methods. Do not use this method
  		//		directly unless you understand its possibly-different implications on the platforms your are targeting.
  		// description:
  		//		Makes an attempt to evaluate scriptText in the global scope. The function works correctly for browsers
  		//		that support indirect eval.
  		//
  		//		As usual, IE does not. On IE, the only way to implement global eval is to
  		//		use execScript. Unfortunately, execScript does not return a value and breaks some current usages of dojo.eval.
  		//		This implementation uses the technique of executing eval in the scope of a function that is a single scope
  		//		frame below the global scope; thereby coming close to the global scope. Note carefully that
  		//
  		//		dojo.eval("var pi = 3.14;");
  		//
  		//		will define global pi in non-IE environments, but define pi only in a temporary local scope for IE. If you want
  		//		to define a global variable using dojo.eval, write something like
  		//
  		//		dojo.eval("window.pi = 3.14;")
  		// scriptText:
  		//		The text to evaluation.
  		// returns:
  		//		The result of the evaluation. Often `undefined`
  	};
  	=====*/
  
  
  	if( 0 ){
  		dojo.exit = function(exitcode){
  			quit(exitcode);
  		};
  	}else{
  		dojo.exit = function(){
  		};
  	}
  
  	 1 || has.add("dojo-guarantee-console",
  		// ensure that console.log, console.warn, etc. are defined
  		1
  	);
  	if( 1 ){
  		typeof console != "undefined" || (console = {});
  		//	Be careful to leave 'log' always at the end
  		var cn = [
  			"assert", "count", "debug", "dir", "dirxml", "error", "group",
  			"groupEnd", "info", "profile", "profileEnd", "time", "timeEnd",
  			"trace", "warn", "log"
  		];
  		var tn;
  		i = 0;
  		while((tn = cn[i++])){
  			if(!console[tn]){
  				(function(){
  					var tcn = tn + "";
  					console[tcn] = ('log' in console) ? function(){
  						var a = Array.apply({}, arguments);
  						a.unshift(tcn + ":");
  						console["log"](a.join(" "));
  					} : function(){};
  					console[tcn]._fake = true;
  				})();
  			}
  		}
  	}
  
  	has.add("dojo-debug-messages",
  		// include dojo.deprecated/dojo.experimental implementations
  		!!config.isDebug
  	);
  	dojo.deprecated = dojo.experimental =  function(){};
  	if(has("dojo-debug-messages")){
  		dojo.deprecated = function(/*String*/ behaviour, /*String?*/ extra, /*String?*/ removal){
  			// summary:
  			//		Log a debug message to indicate that a behavior has been
  			//		deprecated.
  			// behaviour: String
  			//		The API or behavior being deprecated. Usually in the form
  			//		of "myApp.someFunction()".
  			// extra: String?
  			//		Text to append to the message. Often provides advice on a
  			//		new function or facility to achieve the same goal during
  			//		the deprecation period.
  			// removal: String?
  			//		Text to indicate when in the future the behavior will be
  			//		removed. Usually a version number.
  			// example:
  			//	| dojo.deprecated("myApp.getTemp()", "use myApp.getLocaleTemp() instead", "1.0");
  
  			var message = "DEPRECATED: " + behaviour;
  			if(extra){ message += " " + extra; }
  			if(removal){ message += " -- will be removed in version: " + removal; }
  			console.warn(message);
  		};
  
  		dojo.experimental = function(/* String */ moduleName, /* String? */ extra){
  			// summary:
  			//		Marks code as experimental.
  			// description:
  			//		This can be used to mark a function, file, or module as
  			//		experimental.	 Experimental code is not ready to be used, and the
  			//		APIs are subject to change without notice.	Experimental code may be
  			//		completed deleted without going through the normal deprecation
  			//		process.
  			// moduleName: String
  			//		The name of a module, or the name of a module file or a specific
  			//		function
  			// extra: String?
  			//		some additional message for the user
  			// example:
  			//	| dojo.experimental("dojo.data.Result");
  			// example:
  			//	| dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA");
  
  			var message = "EXPERIMENTAL: " + moduleName + " -- APIs subject to change without notice.";
  			if(extra){ message += " " + extra; }
  			console.warn(message);
  		};
  	}
  
  	 1 || has.add("dojo-modulePaths",
  		// consume dojo.modulePaths processing
  		1
  	);
  	if( 1 ){
  		// notice that modulePaths won't be applied to any require's before the dojo/_base/kernel factory is run;
  		// this is the v1.6- behavior.
  		if(config.modulePaths){
  			dojo.deprecated("dojo.modulePaths", "use paths configuration");
  			var paths = {};
  			for(p in config.modulePaths){
  				paths[p.replace(/\./g, "/")] = config.modulePaths[p];
  			}
  			require({paths:paths});
  		}
  	}
  
  	 1 || has.add("dojo-moduleUrl",
  		// include dojo.moduleUrl
  		1
  	);
  	if( 1 ){
  		dojo.moduleUrl = function(/*String*/module, /*String?*/url){
  			// summary:
  			//		Returns a URL relative to a module.
  			// example:
  			//	|	var pngPath = dojo.moduleUrl("acme","images/small.png");
  			//	|	console.dir(pngPath); // list the object properties
  			//	|	// create an image and set it's source to pngPath's value:
  			//	|	var img = document.createElement("img");
  			//	|	img.src = pngPath;
  			//	|	// add our image to the document
  			//	|	dojo.body().appendChild(img);
  			// example:
  			//		you may de-reference as far as you like down the package
  			//		hierarchy.  This is sometimes handy to avoid lenghty relative
  			//		urls or for building portable sub-packages. In this example,
  			//		the `acme.widget` and `acme.util` directories may be located
  			//		under different roots (see `dojo.registerModulePath`) but the
  			//		the modules which reference them can be unaware of their
  			//		relative locations on the filesystem:
  			//	|	// somewhere in a configuration block
  			//	|	dojo.registerModulePath("acme.widget", "../../acme/widget");
  			//	|	dojo.registerModulePath("acme.util", "../../util");
  			//	|
  			//	|	// ...
  			//	|
  			//	|	// code in a module using acme resources
  			//	|	var tmpltPath = dojo.moduleUrl("acme.widget","templates/template.html");
  			//	|	var dataPath = dojo.moduleUrl("acme.util","resources/data.json");
  
  			dojo.deprecated("dojo.moduleUrl()", "use require.toUrl", "2.0");
  
  			// require.toUrl requires a filetype; therefore, just append the suffix "/*.*" to guarantee a filetype, then
  			// remove the suffix from the result. This way clients can request a url w/out a filetype. This should be
  			// rare, but it maintains backcompat for the v1.x line (note: dojo.moduleUrl will be removed in v2.0).
  			// Notice * is an illegal filename so it won't conflict with any real path map that may exist the paths config.
  			var result = null;
  			if(module){
  				result = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : "") + "/*.*").replace(/\/\*\.\*/, "") + (url ? "" : "/");
  			}
  			return result;
  		};
  	}
  
  	dojo._hasResource = {}; // for backward compatibility with layers built with 1.6 tooling
  
  	return dojo;
  });
  