dojo-rails 0.11.0 → 0.14.0

data/vendor/assets/javascripts/dojo/_base/kernel.js.uncompressed.js

@@ -1,299 +0,0 @@
-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: 29458 $".match(/\d+/);
-	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 SVN rev from which dojo was pulled
-
-		major: 1, minor: 8, patch: 0, flag: "",
-		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;
-});

data/vendor/assets/javascripts/dojo/_base/lang.js.uncompressed.js

@@ -1,605 +0,0 @@
-define("dojo/_base/lang", ["./kernel", "../has", "../sniff"], function(dojo, has){
-	// module:
-	//		dojo/_base/lang
-
-	has.add("bug-for-in-skips-shadowed", function(){
-		// if true, the for-in iterator skips object properties that exist in Object's prototype (IE 6 - ?)
-		for(var i in {toString: 1}){
-			return 0;
-		}
-		return 1;
-	});
-
-	// Helper methods
-	var _extraNames =
-			has("bug-for-in-skips-shadowed") ?
-				"hasOwnProperty.valueOf.isPrototypeOf.propertyIsEnumerable.toLocaleString.toString.constructor".split(".") : [],
-
-		_extraLen = _extraNames.length,
-
-		getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){
-			var p, i = 0, dojoGlobal = dojo.global;
-			if(!context){
-				if(!parts.length){
-					return dojoGlobal;
-				}else{
-					p = parts[i++];
-					try{
-						context = dojo.scopeMap[p] && dojo.scopeMap[p][1];
-					}catch(e){}
-					context = context || (p in dojoGlobal ? dojoGlobal[p] : (create ? dojoGlobal[p] = {} : undefined));
-				}
-			}
-			while(context && (p = parts[i++])){
-				context = (p in context ? context[p] : (create ? context[p] = {} : undefined));
-			}
-			return context; // mixed
-		},
-
-		opts = Object.prototype.toString,
-
-		efficient = function(obj, offset, startWith){
-			return (startWith||[]).concat(Array.prototype.slice.call(obj, offset||0));
-		},
-
-		_pattern = /\{([^\}]+)\}/g;
-
-	// Module export
-	var lang = {
-		// summary:
-		//		This module defines Javascript language extensions.
-
-		// _extraNames: String[]
-		//		Lists property names that must be explicitly processed during for-in iteration
-		//		in environments that have has("bug-for-in-skips-shadowed") true.
-		_extraNames:_extraNames,
-
-		_mixin: function(dest, source, copyFunc){
-			// summary:
-			//		Copies/adds all properties of source to dest; returns dest.
-			// dest: Object
-			//		The object to which to copy/add all properties contained in source.
-			// source: Object
-			//		The object from which to draw all properties to copy into dest.
-			// copyFunc: Function?
-			//		The process used to copy/add a property in source; defaults to the Javascript assignment operator.
-			// returns:
-			//		dest, as modified
-			// description:
-			//		All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions
-			//		found in Object.prototype, are copied/added to dest. Copying/adding each particular property is
-			//		delegated to copyFunc (if any); copyFunc defaults to the Javascript assignment operator if not provided.
-			//		Notice that by default, _mixin executes a so-called "shallow copy" and aggregate types are copied/added by reference.
-			var name, s, i, empty = {};
-			for(name in source){
-				// the (!(name in empty) || empty[name] !== s) condition avoids copying properties in "source"
-				// inherited from Object.prototype.	 For example, if dest has a custom toString() method,
-				// don't overwrite it with the toString() method that source inherited from Object.prototype
-				s = source[name];
-				if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
-					dest[name] = copyFunc ? copyFunc(s) : s;
-				}
-			}
-
-			if(has("bug-for-in-skips-shadowed")){
-				if(source){
-					for(i = 0; i < _extraLen; ++i){
-						name = _extraNames[i];
-						s = source[name];
-						if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
-							dest[name] = copyFunc ? copyFunc(s) : s;
-						}
-					}
-				}
-			}
-
-			return dest; // Object
-		},
-
-		mixin: function(dest, sources){
-			// summary:
-			//		Copies/adds all properties of one or more sources to dest; returns dest.
-			// dest: Object
-			//		The object to which to copy/add all properties contained in source. If dest is falsy, then
-			//		a new object is manufactured before copying/adding properties begins.
-			// sources: Object...
-			//		One of more objects from which to draw all properties to copy into dest. sources are processed
-			//		left-to-right and if more than one of these objects contain the same property name, the right-most
-			//		value "wins".
-			// returns: Object
-			//		dest, as modified
-			// description:
-			//		All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions
-			//		found in Object.prototype, are copied/added from sources to dest. sources are processed left to right.
-			//		The Javascript assignment operator is used to copy/add each property; therefore, by default, mixin
-			//		executes a so-called "shallow copy" and aggregate types are copied/added by reference.
-			// example:
-			//		make a shallow copy of an object
-			//	|	var copy = lang.mixin({}, source);
-			// example:
-			//		many class constructors often take an object which specifies
-			//		values to be configured on the object. In this case, it is
-			//		often simplest to call `lang.mixin` on the `this` object:
-			//	|	declare("acme.Base", null, {
-			//	|		constructor: function(properties){
-			//	|			// property configuration:
-			//	|			lang.mixin(this, properties);
-			//	|
-			//	|			console.log(this.quip);
-			//	|			//	...
-			//	|		},
-			//	|		quip: "I wasn't born yesterday, you know - I've seen movies.",
-			//	|		// ...
-			//	|	});
-			//	|
-			//	|	// create an instance of the class and configure it
-			//	|	var b = new acme.Base({quip: "That's what it does!" });
-			// example:
-			//		copy in properties from multiple objects
-			//	|	var flattened = lang.mixin(
-			//	|		{
-			//	|			name: "Frylock",
-			//	|			braces: true
-			//	|		},
-			//	|		{
-			//	|			name: "Carl Brutanananadilewski"
-			//	|		}
-			//	|	);
-			//	|
-			//	|	// will print "Carl Brutanananadilewski"
-			//	|	console.log(flattened.name);
-			//	|	// will print "true"
-			//	|	console.log(flattened.braces);
-
-			if(!dest){ dest = {}; }
-			for(var i = 1, l = arguments.length; i < l; i++){
-				lang._mixin(dest, arguments[i]);
-			}
-			return dest; // Object
-		},
-
-		setObject: function(name, value, context){
-			// summary:
-			//		Set a property from a dot-separated string, such as "A.B.C"
-			// description:
-			//		Useful for longer api chains where you have to test each object in
-			//		the chain, or when you have an object reference in string format.
-			//		Objects are created as needed along `path`. Returns the passed
-			//		value if setting is successful or `undefined` if not.
-			// name: String
-			//		Path to a property, in the form "A.B.C".
-			// value: anything
-			//		value or object to place at location given by name
-			// context: Object?
-			//		Optional. Object to use as root of path. Defaults to
-			//		`dojo.global`.
-			// example:
-			//		set the value of `foo.bar.baz`, regardless of whether
-			//		intermediate objects already exist:
-			//	| lang.setObject("foo.bar.baz", value);
-			// example:
-			//		without `lang.setObject`, we often see code like this:
-			//	| // ensure that intermediate objects are available
-			//	| if(!obj["parent"]){ obj.parent = {}; }
-			//	| if(!obj.parent["child"]){ obj.parent.child = {}; }
-			//	| // now we can safely set the property
-			//	| obj.parent.child.prop = "some value";
-			//		whereas with `lang.setObject`, we can shorten that to:
-			//	| lang.setObject("parent.child.prop", "some value", obj);
-
-			var parts = name.split("."), p = parts.pop(), obj = getProp(parts, true, context);
-			return obj && p ? (obj[p] = value) : undefined; // Object
-		},
-
-		getObject: function(name, create, context){
-			// summary:
-			//		Get a property from a dot-separated string, such as "A.B.C"
-			// description:
-			//		Useful for longer api chains where you have to test each object in
-			//		the chain, or when you have an object reference in string format.
-			// name: String
-			//		Path to an property, in the form "A.B.C".
-			// create: Boolean?
-			//		Optional. Defaults to `false`. If `true`, Objects will be
-			//		created at any point along the 'path' that is undefined.
-			// context: Object?
-			//		Optional. Object to use as root of path. Defaults to
-			//		'dojo.global'. Null may be passed.
-			return getProp(name.split("."), create, context); // Object
-		},
-
-		exists: function(name, obj){
-			// summary:
-			//		determine if an object supports a given method
-			// description:
-			//		useful for longer api chains where you have to test each object in
-			//		the chain. Useful for object and method detection.
-			// name: String
-			//		Path to an object, in the form "A.B.C".
-			// obj: Object?
-			//		Object to use as root of path. Defaults to
-			//		'dojo.global'. Null may be passed.
-			// example:
-			//	| // define an object
-			//	| var foo = {
-			//	|		bar: { }
-			//	| };
-			//	|
-			//	| // search the global scope
-			//	| lang.exists("foo.bar"); // true
-			//	| lang.exists("foo.bar.baz"); // false
-			//	|
-			//	| // search from a particular scope
-			//	| lang.exists("bar", foo); // true
-			//	| lang.exists("bar.baz", foo); // false
-			return lang.getObject(name, false, obj) !== undefined; // Boolean
-		},
-
-		// Crockford (ish) functions
-
-		isString: function(it){
-			// summary:
-			//		Return true if it is a String
-			// it: anything
-			//		Item to test.
-			return (typeof it == "string" || it instanceof String); // Boolean
-		},
-
-		isArray: function(it){
-			// summary:
-			//		Return true if it is an Array.
-			//		Does not work on Arrays created in other windows.
-			// it: anything
-			//		Item to test.
-			return it && (it instanceof Array || typeof it == "array"); // Boolean
-		},
-
-		isFunction: function(it){
-			// summary:
-			//		Return true if it is a Function
-			// it: anything
-			//		Item to test.
-			return opts.call(it) === "[object Function]";
-		},
-
-		isObject: function(it){
-			// summary:
-			//		Returns true if it is a JavaScript object (or an Array, a Function
-			//		or null)
-			// it: anything
-			//		Item to test.
-			return it !== undefined &&
-				(it === null || typeof it == "object" || lang.isArray(it) || lang.isFunction(it)); // Boolean
-		},
-
-		isArrayLike: function(it){
-			// summary:
-			//		similar to isArray() but more permissive
-			// it: anything
-			//		Item to test.
-			// returns:
-			//		If it walks like a duck and quacks like a duck, return `true`
-			// description:
-			//		Doesn't strongly test for "arrayness".  Instead, settles for "isn't
-			//		a string or number and has a length property". Arguments objects
-			//		and DOM collections will return true when passed to
-			//		isArrayLike(), but will return false when passed to
-			//		isArray().
-			return it && it !== undefined && // Boolean
-				// keep out built-in constructors (Number, String, ...) which have length
-				// properties
-				!lang.isString(it) && !lang.isFunction(it) &&
-				!(it.tagName && it.tagName.toLowerCase() == 'form') &&
-				(lang.isArray(it) || isFinite(it.length));
-		},
-
-		isAlien: function(it){
-			// summary:
-			//		Returns true if it is a built-in function or some other kind of
-			//		oddball that *should* report as a function but doesn't
-			return it && !lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
-		},
-
-		extend: function(ctor, props){
-			// summary:
-			//		Adds all properties and methods of props to constructor's
-			//		prototype, making them available to all instances created with
-			//		constructor.
-			// ctor: Object
-			//		Target constructor to extend.
-			// props: Object
-			//		One or more objects to mix into ctor.prototype
-			for(var i=1, l=arguments.length; i<l; i++){
-				lang._mixin(ctor.prototype, arguments[i]);
-			}
-			return ctor; // Object
-		},
-
-		_hitchArgs: function(scope, method){
-			var pre = lang._toArray(arguments, 2);
-			var named = lang.isString(method);
-			return function(){
-				// arrayify arguments
-				var args = lang._toArray(arguments);
-				// locate our method
-				var f = named ? (scope||dojo.global)[method] : method;
-				// invoke with collected args
-				return f && f.apply(scope || this, pre.concat(args)); // mixed
-			}; // Function
-		},
-
-		hitch: function(scope, method){
-			// summary:
-			//		Returns a function that will only ever execute in the a given scope.
-			//		This allows for easy use of object member functions
-			//		in callbacks and other places in which the "this" keyword may
-			//		otherwise not reference the expected scope.
-			//		Any number of default positional arguments may be passed as parameters
-			//		beyond "method".
-			//		Each of these values will be used to "placehold" (similar to curry)
-			//		for the hitched function.
-			// scope: Object
-			//		The scope to use when method executes. If method is a string,
-			//		scope is also the object containing method.
-			// method: Function|String...
-			//		A function to be hitched to scope, or the name of the method in
-			//		scope to be hitched.
-			// example:
-			//	|	lang.hitch(foo, "bar")();
-			//		runs foo.bar() in the scope of foo
-			// example:
-			//	|	lang.hitch(foo, myFunction);
-			//		returns a function that runs myFunction in the scope of foo
-			// example:
-			//		Expansion on the default positional arguments passed along from
-			//		hitch. Passed args are mixed first, additional args after.
-			//	|	var foo = { bar: function(a, b, c){ console.log(a, b, c); } };
-			//	|	var fn = lang.hitch(foo, "bar", 1, 2);
-			//	|	fn(3); // logs "1, 2, 3"
-			// example:
-			//	|	var foo = { bar: 2 };
-			//	|	lang.hitch(foo, function(){ this.bar = 10; })();
-			//		execute an anonymous function in scope of foo
-			if(arguments.length > 2){
-				return lang._hitchArgs.apply(dojo, arguments); // Function
-			}
-			if(!method){
-				method = scope;
-				scope = null;
-			}
-			if(lang.isString(method)){
-				scope = scope || dojo.global;
-				if(!scope[method]){ throw(['lang.hitch: scope["', method, '"] is null (scope="', scope, '")'].join('')); }
-				return function(){ return scope[method].apply(scope, arguments || []); }; // Function
-			}
-			return !scope ? method : function(){ return method.apply(scope, arguments || []); }; // Function
-		},
-
-		delegate: (function(){
-			// boodman/crockford delegation w/ cornford optimization
-			function TMP(){}
-			return function(obj, props){
-				TMP.prototype = obj;
-				var tmp = new TMP();
-				TMP.prototype = null;
-				if(props){
-					lang._mixin(tmp, props);
-				}
-				return tmp; // Object
-			};
-		})(),
-		/*=====
-		delegate: function(obj, props){
-			// summary:
-			//		Returns a new object which "looks" to obj for properties which it
-			//		does not have a value for. Optionally takes a bag of properties to
-			//		seed the returned object with initially.
-			// description:
-			//		This is a small implementation of the Boodman/Crockford delegation
-			//		pattern in JavaScript. An intermediate object constructor mediates
-			//		the prototype chain for the returned object, using it to delegate
-			//		down to obj for property lookup when object-local lookup fails.
-			//		This can be thought of similarly to ES4's "wrap", save that it does
-			//		not act on types but rather on pure objects.
-			// obj: Object
-			//		The object to delegate to for properties not found directly on the
-			//		return object or in props.
-			// props: Object...
-			//		an object containing properties to assign to the returned object
-			// returns:
-			//		an Object of anonymous type
-			// example:
-			//	|	var foo = { bar: "baz" };
-			//	|	var thinger = lang.delegate(foo, { thud: "xyzzy"});
-			//	|	thinger.bar == "baz"; // delegated to foo
-			//	|	foo.thud == undefined; // by definition
-			//	|	thinger.thud == "xyzzy"; // mixed in from props
-			//	|	foo.bar = "thonk";
-			//	|	thinger.bar == "thonk"; // still delegated to foo's bar
-		},
-		=====*/
-
-		_toArray: has("ie") ?
-			(function(){
-				function slow(obj, offset, startWith){
-					var arr = startWith||[];
-					for(var x = offset || 0; x < obj.length; x++){
-						arr.push(obj[x]);
-					}
-					return arr;
-				}
-				return function(obj){
-					return ((obj.item) ? slow : efficient).apply(this, arguments);
-				};
-			})() : efficient,
-		/*=====
-		 _toArray: function(obj, offset, startWith){
-			 // summary:
-			 //		Converts an array-like object (i.e. arguments, DOMCollection) to an
-			 //		array. Returns a new Array with the elements of obj.
-			 // obj: Object
-			 //		the object to "arrayify". We expect the object to have, at a
-			 //		minimum, a length property which corresponds to integer-indexed
-			 //		properties.
-			 // offset: Number?
-			 //		the location in obj to start iterating from. Defaults to 0.
-			 //		Optional.
-			 // startWith: Array?
-			 //		An array to pack with the properties of obj. If provided,
-			 //		properties in obj are appended at the end of startWith and
-			 //		startWith is the returned array.
-		 },
-		 =====*/
-
-		partial: function(/*Function|String*/ method /*, ...*/){
-			// summary:
-			//		similar to hitch() except that the scope object is left to be
-			//		whatever the execution context eventually becomes.
-			// description:
-			//		Calling lang.partial is the functional equivalent of calling:
-			//		|	lang.hitch(null, funcName, ...);
-			// method:
-			//		The function to "wrap"
-			var arr = [ null ];
-			return lang.hitch.apply(dojo, arr.concat(lang._toArray(arguments))); // Function
-		},
-
-		clone: function(/*anything*/ src){
-			// summary:
-			//		Clones objects (including DOM nodes) and all children.
-			//		Warning: do not clone cyclic structures.
-			// src:
-			//		The object to clone
-			if(!src || typeof src != "object" || lang.isFunction(src)){
-				// null, undefined, any non-object, or function
-				return src;	// anything
-			}
-			if(src.nodeType && "cloneNode" in src){
-				// DOM Node
-				return src.cloneNode(true); // Node
-			}
-			if(src instanceof Date){
-				// Date
-				return new Date(src.getTime());	// Date
-			}
-			if(src instanceof RegExp){
-				// RegExp
-				return new RegExp(src);   // RegExp
-			}
-			var r, i, l;
-			if(lang.isArray(src)){
-				// array
-				r = [];
-				for(i = 0, l = src.length; i < l; ++i){
-					if(i in src){
-						r.push(lang.clone(src[i]));
-					}
-				}
-				// we don't clone functions for performance reasons
-				//		}else if(d.isFunction(src)){
-				//			// function
-				//			r = function(){ return src.apply(this, arguments); };
-			}else{
-				// generic objects
-				r = src.constructor ? new src.constructor() : {};
-			}
-			return lang._mixin(r, src, lang.clone);
-		},
-
-
-		trim: String.prototype.trim ?
-			function(str){ return str.trim(); } :
-			function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); },
-		/*=====
-		 trim: function(str){
-			 // summary:
-			 //		Trims whitespace from both sides of the string
-			 // str: String
-			 //		String to be trimmed
-			 // returns: String
-			 //		Returns the trimmed string
-			 // description:
-			 //		This version of trim() was selected for inclusion into the base due
-			 //		to its compact size and relatively good performance
-			 //		(see [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript)
-			 //		Uses String.prototype.trim instead, if available.
-			 //		The fastest but longest version of this function is located at
-			 //		lang.string.trim()
-		 },
-		 =====*/
-
-		replace: function(tmpl, map, pattern){
-			// summary:
-			//		Performs parameterized substitutions on a string. Throws an
-			//		exception if any parameter is unmatched.
-			// tmpl: String
-			//		String to be used as a template.
-			// map: Object|Function
-			//		If an object, it is used as a dictionary to look up substitutions.
-			//		If a function, it is called for every substitution with following parameters:
-			//		a whole match, a name, an offset, and the whole template
-			//		string (see https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace
-			//		for more details).
-			// pattern: RegEx?
-			//		Optional regular expression objects that overrides the default pattern.
-			//		Must be global and match one item. The default is: /\{([^\}]+)\}/g,
-			//		which matches patterns like that: "{xxx}", where "xxx" is any sequence
-			//		of characters, which doesn't include "}".
-			// returns: String
-			//		Returns the substituted string.
-			// example:
-			//	|	// uses a dictionary for substitutions:
-			//	|	lang.replace("Hello, {name.first} {name.last} AKA {nick}!",
-			//	|		{
-			//	|			nick: "Bob",
-			//	|			name: {
-			//	|				first:	"Robert",
-			//	|				middle: "X",
-			//	|				last:		"Cringely"
-			//	|			}
-			//	|		});
-			//	|	// returns: Hello, Robert Cringely AKA Bob!
-			// example:
-			//	|	// uses an array for substitutions:
-			//	|	lang.replace("Hello, {0} {2}!",
-			//	|		["Robert", "X", "Cringely"]);
-			//	|	// returns: Hello, Robert Cringely!
-			// example:
-			//	|	// uses a function for substitutions:
-			//	|	function sum(a){
-			//	|		var t = 0;
-			//	|		arrayforEach(a, function(x){ t += x; });
-			//	|		return t;
-			//	|	}
-			//	|	lang.replace(
-			//	|		"{count} payments averaging {avg} USD per payment.",
-			//	|		lang.hitch(
-			//	|			{ payments: [11, 16, 12] },
-			//	|			function(_, key){
-			//	|				switch(key){
-			//	|					case "count": return this.payments.length;
-			//	|					case "min":		return Math.min.apply(Math, this.payments);
-			//	|					case "max":		return Math.max.apply(Math, this.payments);
-			//	|					case "sum":		return sum(this.payments);
-			//	|					case "avg":		return sum(this.payments) / this.payments.length;
-			//	|				}
-			//	|			}
-			//	|		)
-			//	|	);
-			//	|	// prints: 3 payments averaging 13 USD per payment.
-			// example:
-			//	|	// uses an alternative PHP-like pattern for substitutions:
-			//	|	lang.replace("Hello, ${0} ${2}!",
-			//	|		["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g);
-			//	|	// returns: Hello, Robert Cringely!
-
-			return tmpl.replace(pattern || _pattern, lang.isFunction(map) ?
-				map : function(_, k){ return lang.getObject(k, false, map); });
-		}
-	};
-
-	 1  && lang.mixin(dojo, lang);
-
-	return lang;
-});
-