update dojo to 1.7.3

53 files changed, 7275 insertions, 13273 deletions

diff --git a/lib/dojo/_base/Color.js b/lib/dojo/_base/Color.js
index 4707fa582..ad8e0ab3c 100644
--- a/lib/dojo/_base/Color.js
+++ b/lib/dojo/_base/Color.js
@@ -4,225 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.Color"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.Color"] = true;
-dojo.provide("dojo._base.Color");
-dojo.require("dojo._base.array");
-dojo.require("dojo._base.lang");
-
-
-(function(){
-
-	var d = dojo;
-
-	dojo.Color = function(/*Array|String|Object*/ color){
-		// summary:
-		//	 	Takes a named string, hex string, array of rgb or rgba values,
-		//	 	an object with r, g, b, and a properties, or another `dojo.Color` object
-		//	 	and creates a new Color instance to work from.
-		//
-		// example:
-		//		Work with a Color instance:
-		//	 | var c = new dojo.Color();
-		//	 | c.setColor([0,0,0]); // black
-		//	 | var hex = c.toHex(); // #000000
-		//
-		// example:
-		//		Work with a node's color:
-		//	 | var color = dojo.style("someNode", "backgroundColor");
-		//	 | var n = new dojo.Color(color);
-		//	 | // adjust the color some
-		//	 | n.r *= .5;
-		//	 | console.log(n.toString()); // rgb(128, 255, 255);
-		if(color){ this.setColor(color); }
-	};
-
-	// FIXME:
-	// 	there's got to be a more space-efficient way to encode or discover
-	// 	these!!  Use hex?
-	dojo.Color.named = {
-		black:      [0,0,0],
-		silver:     [192,192,192],
-		gray:       [128,128,128],
-		white:      [255,255,255],
-		maroon:		[128,0,0],
-		red:        [255,0,0],
-		purple:		[128,0,128],
-		fuchsia:	[255,0,255],
-		green:	    [0,128,0],
-		lime:	    [0,255,0],
-		olive:		[128,128,0],
-		yellow:		[255,255,0],
-		navy:       [0,0,128],
-		blue:       [0,0,255],
-		teal:		[0,128,128],
-		aqua:		[0,255,255],
-		transparent: d.config.transparentColor || [255,255,255]
-	};
-
-	dojo.extend(dojo.Color, {
-		r: 255, g: 255, b: 255, a: 1,
-		_set: function(r, g, b, a){
-			var t = this; t.r = r; t.g = g; t.b = b; t.a = a;
-		},
-		setColor: function(/*Array|String|Object*/ color){
-			// summary:
-			//		Takes a named string, hex string, array of rgb or rgba values,
-			//		an object with r, g, b, and a properties, or another `dojo.Color` object
-			//		and sets this color instance to that value.
-			//
-			// example:
-			//	|	var c = new dojo.Color(); // no color
-			//	|	c.setColor("#ededed"); // greyish
-			if(d.isString(color)){
-				d.colorFromString(color, this);
-			}else if(d.isArray(color)){
-				d.colorFromArray(color, this);
-			}else{
-				this._set(color.r, color.g, color.b, color.a);
-				if(!(color instanceof d.Color)){ this.sanitize(); }
-			}
-			return this;	// dojo.Color
-		},
-		sanitize: function(){
-			// summary:
-			//		Ensures the object has correct attributes
-			// description:
-			//		the default implementation does nothing, include dojo.colors to
-			//		augment it with real checks
-			return this;	// dojo.Color
-		},
-		toRgb: function(){
-			// summary:
-			//		Returns 3 component array of rgb values
-			// example:
-			//	|	var c = new dojo.Color("#000000");
-			//	| 	console.log(c.toRgb()); // [0,0,0]
-			var t = this;
-			return [t.r, t.g, t.b];	// Array
-		},
-		toRgba: function(){
-			// summary:
-			//		Returns a 4 component array of rgba values from the color
-			//		represented by this object.
-			var t = this;
-			return [t.r, t.g, t.b, t.a];	// Array
-		},
-		toHex: function(){
-			// summary:
-			//		Returns a CSS color string in hexadecimal representation
-			// example:
-			//	| 	console.log(new dojo.Color([0,0,0]).toHex()); // #000000
-			var arr = d.map(["r", "g", "b"], function(x){
-				var s = this[x].toString(16);
-				return s.length < 2 ? "0" + s : s;
-			}, this);
-			return "#" + arr.join("");	// String
-		},
-		toCss: function(/*Boolean?*/ includeAlpha){
-			// summary:
-			//		Returns a css color string in rgb(a) representation
-			// example:
-			//	|	var c = new dojo.Color("#FFF").toCss();
-			//	|	console.log(c); // rgb('255','255','255')
-			var t = this, rgb = t.r + ", " + t.g + ", " + t.b;
-			return (includeAlpha ? "rgba(" + rgb + ", " + t.a : "rgb(" + rgb) + ")";	// String
-		},
-		toString: function(){
-			// summary:
-			//		Returns a visual representation of the color
-			return this.toCss(true); // String
-		}
-	});
-
-	dojo.blendColors = function(
-		/*dojo.Color*/ start,
-		/*dojo.Color*/ end,
-		/*Number*/ weight,
-		/*dojo.Color?*/ obj
-	){
-		// summary:
-		//		Blend colors end and start with weight from 0 to 1, 0.5 being a 50/50 blend,
-		//		can reuse a previously allocated dojo.Color object for the result
-		var t = obj || new d.Color();
-		d.forEach(["r", "g", "b", "a"], function(x){
-			t[x] = start[x] + (end[x] - start[x]) * weight;
-			if(x != "a"){ t[x] = Math.round(t[x]); }
-		});
-		return t.sanitize();	// dojo.Color
-	};
-
-	dojo.colorFromRgb = function(/*String*/ color, /*dojo.Color?*/ obj){
-		// summary:
-		//		Returns a `dojo.Color` instance from a string of the form
-		//		"rgb(...)" or "rgba(...)". Optionally accepts a `dojo.Color`
-		//		object to update with the parsed value and return instead of
-		//		creating a new object.
-		// returns:
-		//		A dojo.Color object. If obj is passed, it will be the return value.
-		var m = color.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/);
-		return m && dojo.colorFromArray(m[1].split(/\s*,\s*/), obj);	// dojo.Color
-	};
-
-	dojo.colorFromHex = function(/*String*/ color, /*dojo.Color?*/ obj){
-		// summary:
-		//		Converts a hex string with a '#' prefix to a color object.
-		//		Supports 12-bit #rgb shorthand. Optionally accepts a
-		//		`dojo.Color` object to update with the parsed value.
-		//
-		// returns:
-		//		A dojo.Color object. If obj is passed, it will be the return value.
-		//
-		// example:
-		//	 | var thing = dojo.colorFromHex("#ededed"); // grey, longhand
-		//
-		// example:
-		//	| var thing = dojo.colorFromHex("#000"); // black, shorthand
-		var t = obj || new d.Color(),
-			bits = (color.length == 4) ? 4 : 8,
-			mask = (1 << bits) - 1;
-		color = Number("0x" + color.substr(1));
-		if(isNaN(color)){
-			return null; // dojo.Color
-		}
-		d.forEach(["b", "g", "r"], function(x){
-			var c = color & mask;
-			color >>= bits;
-			t[x] = bits == 4 ? 17 * c : c;
-		});
-		t.a = 1;
-		return t;	// dojo.Color
-	};
-
-	dojo.colorFromArray = function(/*Array*/ a, /*dojo.Color?*/ obj){
-		// summary:
-		//		Builds a `dojo.Color` from a 3 or 4 element array, mapping each
-		//		element in sequence to the rgb(a) values of the color.
-		// example:
-		//		| var myColor = dojo.colorFromArray([237,237,237,0.5]); // grey, 50% alpha
-		// returns:
-		//		A dojo.Color object. If obj is passed, it will be the return value.
-		var t = obj || new d.Color();
-		t._set(Number(a[0]), Number(a[1]), Number(a[2]), Number(a[3]));
-		if(isNaN(t.a)){ t.a = 1; }
-		return t.sanitize();	// dojo.Color
-	};
-
-	dojo.colorFromString = function(/*String*/ str, /*dojo.Color?*/ obj){
-		// summary:
-		//		Parses `str` for a color value. Accepts hex, rgb, and rgba
-		//		style color values.
-		// description:
-		//		Acceptable input values for str may include arrays of any form
-		//		accepted by dojo.colorFromArray, hex strings such as "#aaaaaa", or
-		//		rgb or rgba strings such as "rgb(133, 200, 16)" or "rgba(10, 10,
-		//		10, 50)"
-		// returns:
-		//		A dojo.Color object. If obj is passed, it will be the return value.
-		var a = d.Color.named[str];
-		return a && d.colorFromArray(a, obj) || d.colorFromRgb(str, obj) || d.colorFromHex(str, obj);
-	};
-})();
-
-}
+//>>built
+define("dojo/_base/Color",["./kernel","./lang","./array","./config"],function(_1,_2,_3,_4){var _5=_1.Color=function(_6){if(_6){this.setColor(_6);}};_5.named={"black":[0,0,0],"silver":[192,192,192],"gray":[128,128,128],"white":[255,255,255],"maroon":[128,0,0],"red":[255,0,0],"purple":[128,0,128],"fuchsia":[255,0,255],"green":[0,128,0],"lime":[0,255,0],"olive":[128,128,0],"yellow":[255,255,0],"navy":[0,0,128],"blue":[0,0,255],"teal":[0,128,128],"aqua":[0,255,255],"transparent":_4.transparentColor||[0,0,0,0]};_2.extend(_5,{r:255,g:255,b:255,a:1,_set:function(r,g,b,a){var t=this;t.r=r;t.g=g;t.b=b;t.a=a;},setColor:function(_7){if(_2.isString(_7)){_5.fromString(_7,this);}else{if(_2.isArray(_7)){_5.fromArray(_7,this);}else{this._set(_7.r,_7.g,_7.b,_7.a);if(!(_7 instanceof _5)){this.sanitize();}}}return this;},sanitize:function(){return this;},toRgb:function(){var t=this;return [t.r,t.g,t.b];},toRgba:function(){var t=this;return [t.r,t.g,t.b,t.a];},toHex:function(){var _8=_3.map(["r","g","b"],function(x){var s=this[x].toString(16);return s.length<2?"0"+s:s;},this);return "#"+_8.join("");},toCss:function(_9){var t=this,_a=t.r+", "+t.g+", "+t.b;return (_9?"rgba("+_a+", "+t.a:"rgb("+_a)+")";},toString:function(){return this.toCss(true);}});_5.blendColors=_1.blendColors=function(_b,_c,_d,_e){var t=_e||new _5();_3.forEach(["r","g","b","a"],function(x){t[x]=_b[x]+(_c[x]-_b[x])*_d;if(x!="a"){t[x]=Math.round(t[x]);}});return t.sanitize();};_5.fromRgb=_1.colorFromRgb=function(_f,obj){var m=_f.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/);return m&&_5.fromArray(m[1].split(/\s*,\s*/),obj);};_5.fromHex=_1.colorFromHex=function(_10,obj){var t=obj||new _5(),_11=(_10.length==4)?4:8,_12=(1<<_11)-1;_10=Number("0x"+_10.substr(1));if(isNaN(_10)){return null;}_3.forEach(["b","g","r"],function(x){var c=_10&_12;_10>>=_11;t[x]=_11==4?17*c:c;});t.a=1;return t;};_5.fromArray=_1.colorFromArray=function(a,obj){var t=obj||new _5();t._set(Number(a[0]),Number(a[1]),Number(a[2]),Number(a[3]));if(isNaN(t.a)){t.a=1;}return t.sanitize();};_5.fromString=_1.colorFromString=function(str,obj){var a=_5.named[str];return a&&_5.fromArray(a,obj)||_5.fromRgb(str,obj)||_5.fromHex(str,obj);};return _5;});
\ No newline at end of file
diff --git a/lib/dojo/_base/Color.js.uncompressed.js b/lib/dojo/_base/Color.js.uncompressed.js
new file mode 100644
index 000000000..ed0918093
--- /dev/null
+++ b/lib/dojo/_base/Color.js.uncompressed.js
@@ -0,0 +1,220 @@
+define("dojo/_base/Color", ["./kernel", "./lang", "./array", "./config"], function(dojo, lang, ArrayUtil, config){
+
+	var Color = dojo.Color = function(/*Array|String|Object*/ color){
+		// summary:
+		//		Takes a named string, hex string, array of rgb or rgba values,
+		//		an object with r, g, b, and a properties, or another `dojo.Color` object
+		//		and creates a new Color instance to work from.
+		//
+		// example:
+		//		Work with a Color instance:
+		//	 | var c = new dojo.Color();
+		//	 | c.setColor([0,0,0]); // black
+		//	 | var hex = c.toHex(); // #000000
+		//
+		// example:
+		//		Work with a node's color:
+		//	 | var color = dojo.style("someNode", "backgroundColor");
+		//	 | var n = new dojo.Color(color);
+		//	 | // adjust the color some
+		//	 | n.r *= .5;
+		//	 | console.log(n.toString()); // rgb(128, 255, 255);
+		if(color){ this.setColor(color); }
+	};
+
+	/*=====
+	lang.mixin(dojo.Color,{
+		named:{
+			// summary: Dictionary list of all CSS named colors, by name. Values are 3-item arrays with corresponding RG and B values.
+		}
+	});
+	=====*/
+
+	// FIXME:
+	// there's got to be a more space-efficient way to encode or discover
+	// these!! Use hex?
+	Color.named = {
+		"black":  [0,0,0],
+		"silver": [192,192,192],
+		"gray":	  [128,128,128],
+		"white":  [255,255,255],
+		"maroon": [128,0,0],
+		"red":	  [255,0,0],
+		"purple": [128,0,128],
+		"fuchsia":[255,0,255],
+		"green":  [0,128,0],
+		"lime":	  [0,255,0],
+		"olive":  [128,128,0],
+		"yellow": [255,255,0],
+		"navy":	  [0,0,128],
+		"blue":	  [0,0,255],
+		"teal":	  [0,128,128],
+		"aqua":	  [0,255,255],
+		"transparent": config.transparentColor || [0,0,0,0]
+	};
+
+	lang.extend(Color, {
+		r: 255, g: 255, b: 255, a: 1,
+		_set: function(r, g, b, a){
+			var t = this; t.r = r; t.g = g; t.b = b; t.a = a;
+		},
+		setColor: function(/*Array|String|Object*/ color){
+			// summary:
+			//		Takes a named string, hex string, array of rgb or rgba values,
+			//		an object with r, g, b, and a properties, or another `dojo.Color` object
+			//		and sets this color instance to that value.
+			//
+			// example:
+			//	|	var c = new dojo.Color(); // no color
+			//	|	c.setColor("#ededed"); // greyish
+			if(lang.isString(color)){
+				Color.fromString(color, this);
+			}else if(lang.isArray(color)){
+				Color.fromArray(color, this);
+			}else{
+				this._set(color.r, color.g, color.b, color.a);
+				if(!(color instanceof Color)){ this.sanitize(); }
+			}
+			return this;	// dojo.Color
+		},
+		sanitize: function(){
+			// summary:
+			//		Ensures the object has correct attributes
+			// description:
+			//		the default implementation does nothing, include dojo.colors to
+			//		augment it with real checks
+			return this;	// dojo.Color
+		},
+		toRgb: function(){
+			// summary:
+			//		Returns 3 component array of rgb values
+			// example:
+			//	|	var c = new dojo.Color("#000000");
+			//	|	console.log(c.toRgb()); // [0,0,0]
+			var t = this;
+			return [t.r, t.g, t.b]; // Array
+		},
+		toRgba: function(){
+			// summary:
+			//		Returns a 4 component array of rgba values from the color
+			//		represented by this object.
+			var t = this;
+			return [t.r, t.g, t.b, t.a];	// Array
+		},
+		toHex: function(){
+			// summary:
+			//		Returns a CSS color string in hexadecimal representation
+			// example:
+			//	|	console.log(new dojo.Color([0,0,0]).toHex()); // #000000
+			var arr = ArrayUtil.map(["r", "g", "b"], function(x){
+				var s = this[x].toString(16);
+				return s.length < 2 ? "0" + s : s;
+			}, this);
+			return "#" + arr.join("");	// String
+		},
+		toCss: function(/*Boolean?*/ includeAlpha){
+			// summary:
+			//		Returns a css color string in rgb(a) representation
+			// example:
+			//	|	var c = new dojo.Color("#FFF").toCss();
+			//	|	console.log(c); // rgb('255','255','255')
+			var t = this, rgb = t.r + ", " + t.g + ", " + t.b;
+			return (includeAlpha ? "rgba(" + rgb + ", " + t.a : "rgb(" + rgb) + ")";	// String
+		},
+		toString: function(){
+			// summary:
+			//		Returns a visual representation of the color
+			return this.toCss(true); // String
+		}
+	});
+
+	Color.blendColors = dojo.blendColors = function(
+		/*dojo.Color*/ start,
+		/*dojo.Color*/ end,
+		/*Number*/ weight,
+		/*dojo.Color?*/ obj
+	){
+		// summary:
+		//		Blend colors end and start with weight from 0 to 1, 0.5 being a 50/50 blend,
+		//		can reuse a previously allocated dojo.Color object for the result
+		var t = obj || new Color();
+		ArrayUtil.forEach(["r", "g", "b", "a"], function(x){
+			t[x] = start[x] + (end[x] - start[x]) * weight;
+			if(x != "a"){ t[x] = Math.round(t[x]); }
+		});
+		return t.sanitize();	// dojo.Color
+	};
+
+	Color.fromRgb = dojo.colorFromRgb = function(/*String*/ color, /*dojo.Color?*/ obj){
+		// summary:
+		//		Returns a `dojo.Color` instance from a string of the form
+		//		"rgb(...)" or "rgba(...)". Optionally accepts a `dojo.Color`
+		//		object to update with the parsed value and return instead of
+		//		creating a new object.
+		// returns:
+		//		A dojo.Color object. If obj is passed, it will be the return value.
+		var m = color.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/);
+		return m && Color.fromArray(m[1].split(/\s*,\s*/), obj);	// dojo.Color
+	};
+
+	Color.fromHex = dojo.colorFromHex = function(/*String*/ color, /*dojo.Color?*/ obj){
+		// summary:
+		//		Converts a hex string with a '#' prefix to a color object.
+		//		Supports 12-bit #rgb shorthand. Optionally accepts a
+		//		`dojo.Color` object to update with the parsed value.
+		//
+		// returns:
+		//		A dojo.Color object. If obj is passed, it will be the return value.
+		//
+		// example:
+		//	 | var thing = dojo.colorFromHex("#ededed"); // grey, longhand
+		//
+		// example:
+		//	| var thing = dojo.colorFromHex("#000"); // black, shorthand
+		var t = obj || new Color(),
+			bits = (color.length == 4) ? 4 : 8,
+			mask = (1 << bits) - 1;
+		color = Number("0x" + color.substr(1));
+		if(isNaN(color)){
+			return null; // dojo.Color
+		}
+		ArrayUtil.forEach(["b", "g", "r"], function(x){
+			var c = color & mask;
+			color >>= bits;
+			t[x] = bits == 4 ? 17 * c : c;
+		});
+		t.a = 1;
+		return t;	// dojo.Color
+	};
+
+	Color.fromArray = dojo.colorFromArray = function(/*Array*/ a, /*dojo.Color?*/ obj){
+		// summary:
+		//		Builds a `dojo.Color` from a 3 or 4 element array, mapping each
+		//		element in sequence to the rgb(a) values of the color.
+		// example:
+		//		| var myColor = dojo.colorFromArray([237,237,237,0.5]); // grey, 50% alpha
+		// returns:
+		//		A dojo.Color object. If obj is passed, it will be the return value.
+		var t = obj || new Color();
+		t._set(Number(a[0]), Number(a[1]), Number(a[2]), Number(a[3]));
+		if(isNaN(t.a)){ t.a = 1; }
+		return t.sanitize();	// dojo.Color
+	};
+
+	Color.fromString = dojo.colorFromString = function(/*String*/ str, /*dojo.Color?*/ obj){
+		// summary:
+		//		Parses `str` for a color value. Accepts hex, rgb, and rgba
+		//		style color values.
+		// description:
+		//		Acceptable input values for str may include arrays of any form
+		//		accepted by dojo.colorFromArray, hex strings such as "#aaaaaa", or
+		//		rgb or rgba strings such as "rgb(133, 200, 16)" or "rgba(10, 10,
+		//		10, 50)"
+		// returns:
+		//		A dojo.Color object. If obj is passed, it will be the return value.
+		var a = Color.named[str];
+		return a && Color.fromArray(a, obj) || Color.fromRgb(str, obj) || Color.fromHex(str, obj);	// dojo.Color
+	};
+
+	return Color;
+});
diff --git a/lib/dojo/_base/Deferred.js b/lib/dojo/_base/Deferred.js
index c5992c966..13609f687 100644
--- a/lib/dojo/_base/Deferred.js
+++ b/lib/dojo/_base/Deferred.js
@@ -4,343 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.Deferred"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.Deferred"] = true;
-dojo.provide("dojo._base.Deferred");
-dojo.require("dojo._base.lang");
-
-
-(function(){
-	var mutator = function(){};
-	var freeze = Object.freeze || function(){};
-	// A deferred provides an API for creating and resolving a promise.
-	dojo.Deferred = function(/*Function?*/canceller){
-	// summary:
-	//		Deferreds provide a generic means for encapsulating an asynchronous
-	// 		operation and notifying users of the completion and result of the operation.
-	// description:
-	//		The dojo.Deferred API is based on the concept of promises that provide a
-	//		generic interface into the eventual completion of an asynchronous action.
-	//		The motivation for promises fundamentally is about creating a
-	//		separation of concerns that allows one to achieve the same type of
-	//		call patterns and logical data flow in asynchronous code as can be
-	//		achieved in synchronous code. Promises allows one
-	//		to be able to call a function purely with arguments needed for
-	//		execution, without conflating the call with concerns of whether it is
-	//		sync or async. One shouldn't need to alter a call's arguments if the
-	//		implementation switches from sync to async (or vice versa). By having
-	//		async functions return promises, the concerns of making the call are
-	//		separated from the concerns of asynchronous interaction (which are
-	//		handled by the promise).
-	//
-	//  	The dojo.Deferred is a type of promise that provides methods for fulfilling the
-	// 		promise with a successful result or an error. The most important method for
-	// 		working with Dojo's promises is the then() method, which follows the
-	// 		CommonJS proposed promise API. An example of using a Dojo promise:
-	//
-	//		| 	var resultingPromise = someAsyncOperation.then(function(result){
-	//		|		... handle result ...
-	//		|	},
-	//		|	function(error){
-	//		|		... handle error ...
-	//		|	});
-	//
-	//		The .then() call returns a new promise that represents the result of the
-	// 		execution of the callback. The callbacks will never affect the original promises value.
-	//
-	//		The dojo.Deferred instances also provide the following functions for backwards compatibility:
-	//
-	//			* addCallback(handler)
-	//			* addErrback(handler)
-	//			* callback(result)
-	//			* errback(result)
-	//
-	//		Callbacks are allowed to return promises themselves, so
-	//		you can build complicated sequences of events with ease.
-	//
-	//		The creator of the Deferred may specify a canceller.  The canceller
-	//		is a function that will be called if Deferred.cancel is called
-	//		before the Deferred fires. You can use this to implement clean
-	//		aborting of an XMLHttpRequest, etc. Note that cancel will fire the
-	//		deferred with a CancelledError (unless your canceller returns
-	//		another kind of error), so the errbacks should be prepared to
-	//		handle that error for cancellable Deferreds.
-	// example:
-	//	|	var deferred = new dojo.Deferred();
-	//	|	setTimeout(function(){ deferred.callback({success: true}); }, 1000);
-	//	|	return deferred;
-	// example:
-	//		Deferred objects are often used when making code asynchronous. It
-	//		may be easiest to write functions in a synchronous manner and then
-	//		split code using a deferred to trigger a response to a long-lived
-	//		operation. For example, instead of register a callback function to
-	//		denote when a rendering operation completes, the function can
-	//		simply return a deferred:
-	//
-	//		|	// callback style:
-	//		|	function renderLotsOfData(data, callback){
-	//		|		var success = false
-	//		|		try{
-	//		|			for(var x in data){
-	//		|				renderDataitem(data[x]);
-	//		|			}
-	//		|			success = true;
-	//		|		}catch(e){ }
-	//		|		if(callback){
-	//		|			callback(success);
-	//		|		}
-	//		|	}
-	//
-	//		|	// using callback style
-	//		|	renderLotsOfData(someDataObj, function(success){
-	//		|		// handles success or failure
-	//		|		if(!success){
-	//		|			promptUserToRecover();
-	//		|		}
-	//		|	});
-	//		|	// NOTE: no way to add another callback here!!
-	// example:
-	//		Using a Deferred doesn't simplify the sending code any, but it
-	//		provides a standard interface for callers and senders alike,
-	//		providing both with a simple way to service multiple callbacks for
-	//		an operation and freeing both sides from worrying about details
-	//		such as "did this get called already?". With Deferreds, new
-	//		callbacks can be added at any time.
-	//
-	//		|	// Deferred style:
-	//		|	function renderLotsOfData(data){
-	//		|		var d = new dojo.Deferred();
-	//		|		try{
-	//		|			for(var x in data){
-	//		|				renderDataitem(data[x]);
-	//		|			}
-	//		|			d.callback(true);
-	//		|		}catch(e){
-	//		|			d.errback(new Error("rendering failed"));
-	//		|		}
-	//		|		return d;
-	//		|	}
-	//
-	//		|	// using Deferred style
-	//		|	renderLotsOfData(someDataObj).then(null, function(){
-	//		|		promptUserToRecover();
-	//		|	});
-	//		|	// NOTE: addErrback and addCallback both return the Deferred
-	//		|	// again, so we could chain adding callbacks or save the
-	//		|	// deferred for later should we need to be notified again.
-	// example:
-	//		In this example, renderLotsOfData is synchronous and so both
-	//		versions are pretty artificial. Putting the data display on a
-	//		timeout helps show why Deferreds rock:
-	//
-	//		|	// Deferred style and async func
-	//		|	function renderLotsOfData(data){
-	//		|		var d = new dojo.Deferred();
-	//		|		setTimeout(function(){
-	//		|			try{
-	//		|				for(var x in data){
-	//		|					renderDataitem(data[x]);
-	//		|				}
-	//		|				d.callback(true);
-	//		|			}catch(e){
-	//		|				d.errback(new Error("rendering failed"));
-	//		|			}
-	//		|		}, 100);
-	//		|		return d;
-	//		|	}
-	//
-	//		|	// using Deferred style
-	//		|	renderLotsOfData(someDataObj).then(null, function(){
-	//		|		promptUserToRecover();
-	//		|	});
-	//
-	//		Note that the caller doesn't have to change his code at all to
-	//		handle the asynchronous case.
-		var result, finished, isError, head, nextListener;
-		var promise = (this.promise = {});
-		
-		function complete(value){
-			if(finished){
-				throw new Error("This deferred has already been resolved");
-			}
-			result = value;
-			finished = true;
-			notify();
-		}
-		function notify(){
-			var mutated;
-			while(!mutated && nextListener){
-				var listener = nextListener;
-				nextListener = nextListener.next;
-				if((mutated = (listener.progress == mutator))){ // assignment and check
-					finished = false;
-				}
-				var func = (isError ? listener.error : listener.resolved);
-				if (func) {
-					try {
-						var newResult = func(result);
-						if (newResult && typeof newResult.then === "function") {
-							newResult.then(dojo.hitch(listener.deferred, "resolve"), dojo.hitch(listener.deferred, "reject"));
-							continue;
-						}
-						var unchanged = mutated && newResult === undefined;
-						if(mutated && !unchanged){
-							isError = newResult instanceof Error;
-						}
-						listener.deferred[unchanged && isError ? "reject" : "resolve"](unchanged ? result : newResult);
-					}
-					catch (e) {
-						listener.deferred.reject(e);
-					}
-				}else {
-					if(isError){
-						listener.deferred.reject(result);
-					}else{
-						listener.deferred.resolve(result);
-					}
-				}
-			}
-		}
-		// calling resolve will resolve the promise
-		this.resolve = this.callback = function(value){
-			// summary:
-			//		Fulfills the Deferred instance successfully with the provide value
-			this.fired = 0;
-			this.results = [value, null];
-			complete(value);
-		};
-		
-		
-		// calling error will indicate that the promise failed
-		this.reject = this.errback = function(error){
-			// summary:
-			//		Fulfills the Deferred instance as an error with the provided error
-			isError = true;
-			this.fired = 1;
-			complete(error);
-			this.results = [null, error];
-			if(!error || error.log !== false){
-				(dojo.config.deferredOnError || function(x){ console.error(x); })(error);
-			}
-		};
-		// call progress to provide updates on the progress on the completion of the promise
-		this.progress = function(update){
-			// summary
-			//		Send progress events to all listeners
-			var listener = nextListener;
-			while(listener){
-				var progress = listener.progress;
-				progress && progress(update);
-				listener = listener.next;
-			}
-		};
-		this.addCallbacks = function(/*Function?*/callback, /*Function?*/errback){
-			this.then(callback, errback, mutator);
-			return this;
-		};
-		// provide the implementation of the promise
-		this.then = promise.then = function(/*Function?*/resolvedCallback, /*Function?*/errorCallback, /*Function?*/progressCallback){
-			// summary:
-			// 		Adds a fulfilledHandler, errorHandler, and progressHandler to be called for
-			// 		completion of a promise. The fulfilledHandler is called when the promise
-			// 		is fulfilled. The errorHandler is called when a promise fails. The
-			// 		progressHandler is called for progress events. All arguments are optional
-			// 		and non-function values are ignored. The progressHandler is not only an
-			// 		optional argument, but progress events are purely optional. Promise
-			// 		providers are not required to ever create progress events.
-			//
-			// 		This function will return a new promise that is fulfilled when the given
-			// 		fulfilledHandler or errorHandler callback is finished. This allows promise
-			// 		operations to be chained together. The value returned from the callback
-			// 		handler is the fulfillment value for the returned promise. If the callback
-			// 		throws an error, the returned promise will be moved to failed state.
-			//
-			// example:
-			// 		An example of using a CommonJS compliant promise:
-  			//		|	asyncComputeTheAnswerToEverything().
-			//		|		then(addTwo).
-			//		|		then(printResult, onError);
-  			//		|	>44
-			//
-			var returnDeferred = progressCallback == mutator ? this : new dojo.Deferred(promise.cancel);
-			var listener = {
-				resolved: resolvedCallback,
-				error: errorCallback,
-				progress: progressCallback,
-				deferred: returnDeferred
-			};
-			if(nextListener){
-				head = head.next = listener;
-			}
-			else{
-				nextListener = head = listener;
-			}
-			if(finished){
-				notify();
-			}
-			return returnDeferred.promise;
-		};
-		var deferred = this;
-		this.cancel = promise.cancel = function () {
-			// summary:
-			//		Cancels the asynchronous operation
-			if(!finished){
-				var error = canceller && canceller(deferred);
-				if(!finished){
-					if (!(error instanceof Error)) {
-						error = new Error(error);
-					}
-					error.log = false;
-					deferred.reject(error);
-				}
-			}
-		};
-		freeze(promise);
-	};
-	dojo.extend(dojo.Deferred, {
-		addCallback: function (/*Function*/callback) {
-			return this.addCallbacks(dojo.hitch.apply(dojo, arguments));
-		},
-	
-		addErrback: function (/*Function*/errback) {
-			return this.addCallbacks(null, dojo.hitch.apply(dojo, arguments));
-		},
-	
-		addBoth: function (/*Function*/callback) {
-			var enclosed = dojo.hitch.apply(dojo, arguments);
-			return this.addCallbacks(enclosed, enclosed);
-		},
-		fired: -1
-	});
-})();
-dojo.when = function(promiseOrValue, /*Function?*/callback, /*Function?*/errback, /*Function?*/progressHandler){
-	// summary:
-	//		This provides normalization between normal synchronous values and
-	//		asynchronous promises, so you can interact with them in a common way
-	//	example:
-	//		|	function printFirstAndList(items){
-	//		|		dojo.when(findFirst(items), console.log);
-	//		|		dojo.when(findLast(items), console.log);
-	//		|	}
-	//		|	function findFirst(items){
-	//		|		return dojo.when(items, function(items){
-	//		|			return items[0];
-	//		|		});
-	//		|	}
-	//		|	function findLast(items){
-	//		|		return dojo.when(items, function(items){
-	//		|			return items[items.length];
-	//		|		});
-	//		|	}
-	//		And now all three of his functions can be used sync or async.
-	//		|	printFirstAndLast([1,2,3,4]) will work just as well as
-	//		|	printFirstAndLast(dojo.xhrGet(...));
-	
-	if(promiseOrValue && typeof promiseOrValue.then === "function"){
-		return promiseOrValue.then(callback, errback, progressHandler);
-	}
-	return callback(promiseOrValue);
-};
-
-}
+//>>built
+define("dojo/_base/Deferred",["./kernel","./lang"],function(_1,_2){var _3=function(){};var _4=Object.freeze||function(){};_1.Deferred=function(_5){var _6,_7,_8,_9,_a;var _b=(this.promise={});function _c(_d){if(_7){throw new Error("This deferred has already been resolved");}_6=_d;_7=true;_e();};function _e(){var _f;while(!_f&&_a){var _10=_a;_a=_a.next;if((_f=(_10.progress==_3))){_7=false;}var _11=(_8?_10.error:_10.resolved);if(_11){try{var _12=_11(_6);if(_12&&typeof _12.then==="function"){_12.then(_2.hitch(_10.deferred,"resolve"),_2.hitch(_10.deferred,"reject"),_2.hitch(_10.deferred,"progress"));continue;}var _13=_f&&_12===undefined;if(_f&&!_13){_8=_12 instanceof Error;}_10.deferred[_13&&_8?"reject":"resolve"](_13?_6:_12);}catch(e){_10.deferred.reject(e);}}else{if(_8){_10.deferred.reject(_6);}else{_10.deferred.resolve(_6);}}}};this.resolve=this.callback=function(_14){this.fired=0;this.results=[_14,null];_c(_14);};this.reject=this.errback=function(_15){_8=true;this.fired=1;_c(_15);this.results=[null,_15];if(!_15||_15.log!==false){(_1.config.deferredOnError||function(x){console.error(x);})(_15);}};this.progress=function(_16){var _17=_a;while(_17){var _18=_17.progress;_18&&_18(_16);_17=_17.next;}};this.addCallbacks=function(_19,_1a){this.then(_19,_1a,_3);return this;};_b.then=this.then=function(_1b,_1c,_1d){var _1e=_1d==_3?this:new _1.Deferred(_b.cancel);var _1f={resolved:_1b,error:_1c,progress:_1d,deferred:_1e};if(_a){_9=_9.next=_1f;}else{_a=_9=_1f;}if(_7){_e();}return _1e.promise;};var _20=this;_b.cancel=this.cancel=function(){if(!_7){var _21=_5&&_5(_20);if(!_7){if(!(_21 instanceof Error)){_21=new Error(_21);}_21.log=false;_20.reject(_21);}}};_4(_b);};_2.extend(_1.Deferred,{addCallback:function(_22){return this.addCallbacks(_2.hitch.apply(_1,arguments));},addErrback:function(_23){return this.addCallbacks(null,_2.hitch.apply(_1,arguments));},addBoth:function(_24){var _25=_2.hitch.apply(_1,arguments);return this.addCallbacks(_25,_25);},fired:-1});_1.Deferred.when=_1.when=function(_26,_27,_28,_29){if(_26&&typeof _26.then==="function"){return _26.then(_27,_28,_29);}return _27?_27(_26):_26;};return _1.Deferred;});
\ No newline at end of file
diff --git a/lib/dojo/_base/Deferred.js.uncompressed.js b/lib/dojo/_base/Deferred.js.uncompressed.js
new file mode 100644
index 000000000..6dc39e96c
--- /dev/null
+++ b/lib/dojo/_base/Deferred.js.uncompressed.js
@@ -0,0 +1,366 @@
+define("dojo/_base/Deferred", ["./kernel", "./lang"], function(dojo, lang){
+	// module:
+	//		dojo/_base/Deferred
+	// summary:
+	//		This module defines dojo.Deferred.
+
+	var mutator = function(){};
+	var freeze = Object.freeze || function(){};
+	// A deferred provides an API for creating and resolving a promise.
+	dojo.Deferred = function(/*Function?*/ canceller){
+		// summary:
+		//		Deferreds provide a generic means for encapsulating an asynchronous
+		//		operation and notifying users of the completion and result of the operation.
+		// description:
+		//		The dojo.Deferred API is based on the concept of promises that provide a
+		//		generic interface into the eventual completion of an asynchronous action.
+		//		The motivation for promises fundamentally is about creating a
+		//		separation of concerns that allows one to achieve the same type of
+		//		call patterns and logical data flow in asynchronous code as can be
+		//		achieved in synchronous code. Promises allows one
+		//		to be able to call a function purely with arguments needed for
+		//		execution, without conflating the call with concerns of whether it is
+		//		sync or async. One shouldn't need to alter a call's arguments if the
+		//		implementation switches from sync to async (or vice versa). By having
+		//		async functions return promises, the concerns of making the call are
+		//		separated from the concerns of asynchronous interaction (which are
+		//		handled by the promise).
+		//
+		//		The dojo.Deferred is a type of promise that provides methods for fulfilling the
+		//		promise with a successful result or an error. The most important method for
+		//		working with Dojo's promises is the then() method, which follows the
+		//		CommonJS proposed promise API. An example of using a Dojo promise:
+		//
+		//		|	var resultingPromise = someAsyncOperation.then(function(result){
+		//		|		... handle result ...
+		//		|	},
+		//		|	function(error){
+		//		|		... handle error ...
+		//		|	});
+		//
+		//		The .then() call returns a new promise that represents the result of the
+		//		execution of the callback. The callbacks will never affect the original promises value.
+		//
+		//		The dojo.Deferred instances also provide the following functions for backwards compatibility:
+		//
+		//			* addCallback(handler)
+		//			* addErrback(handler)
+		//			* callback(result)
+		//			* errback(result)
+		//
+		//		Callbacks are allowed to return promises themselves, so
+		//		you can build complicated sequences of events with ease.
+		//
+		//		The creator of the Deferred may specify a canceller.  The canceller
+		//		is a function that will be called if Deferred.cancel is called
+		//		before the Deferred fires. You can use this to implement clean
+		//		aborting of an XMLHttpRequest, etc. Note that cancel will fire the
+		//		deferred with a CancelledError (unless your canceller returns
+		//		another kind of error), so the errbacks should be prepared to
+		//		handle that error for cancellable Deferreds.
+		// example:
+		//	|	var deferred = new dojo.Deferred();
+		//	|	setTimeout(function(){ deferred.callback({success: true}); }, 1000);
+		//	|	return deferred;
+		// example:
+		//		Deferred objects are often used when making code asynchronous. It
+		//		may be easiest to write functions in a synchronous manner and then
+		//		split code using a deferred to trigger a response to a long-lived
+		//		operation. For example, instead of register a callback function to
+		//		denote when a rendering operation completes, the function can
+		//		simply return a deferred:
+		//
+		//		|	// callback style:
+		//		|	function renderLotsOfData(data, callback){
+		//		|		var success = false
+		//		|		try{
+		//		|			for(var x in data){
+		//		|				renderDataitem(data[x]);
+		//		|			}
+		//		|			success = true;
+		//		|		}catch(e){ }
+		//		|		if(callback){
+		//		|			callback(success);
+		//		|		}
+		//		|	}
+		//
+		//		|	// using callback style
+		//		|	renderLotsOfData(someDataObj, function(success){
+		//		|		// handles success or failure
+		//		|		if(!success){
+		//		|			promptUserToRecover();
+		//		|		}
+		//		|	});
+		//		|	// NOTE: no way to add another callback here!!
+		// example:
+		//		Using a Deferred doesn't simplify the sending code any, but it
+		//		provides a standard interface for callers and senders alike,
+		//		providing both with a simple way to service multiple callbacks for
+		//		an operation and freeing both sides from worrying about details
+		//		such as "did this get called already?". With Deferreds, new
+		//		callbacks can be added at any time.
+		//
+		//		|	// Deferred style:
+		//		|	function renderLotsOfData(data){
+		//		|		var d = new dojo.Deferred();
+		//		|		try{
+		//		|			for(var x in data){
+		//		|				renderDataitem(data[x]);
+		//		|			}
+		//		|			d.callback(true);
+		//		|		}catch(e){
+		//		|			d.errback(new Error("rendering failed"));
+		//		|		}
+		//		|		return d;
+		//		|	}
+		//
+		//		|	// using Deferred style
+		//		|	renderLotsOfData(someDataObj).then(null, function(){
+		//		|		promptUserToRecover();
+		//		|	});
+		//		|	// NOTE: addErrback and addCallback both return the Deferred
+		//		|	// again, so we could chain adding callbacks or save the
+		//		|	// deferred for later should we need to be notified again.
+		// example:
+		//		In this example, renderLotsOfData is synchronous and so both
+		//		versions are pretty artificial. Putting the data display on a
+		//		timeout helps show why Deferreds rock:
+		//
+		//		|	// Deferred style and async func
+		//		|	function renderLotsOfData(data){
+		//		|		var d = new dojo.Deferred();
+		//		|		setTimeout(function(){
+		//		|			try{
+		//		|				for(var x in data){
+		//		|					renderDataitem(data[x]);
+		//		|				}
+		//		|				d.callback(true);
+		//		|			}catch(e){
+		//		|				d.errback(new Error("rendering failed"));
+		//		|			}
+		//		|		}, 100);
+		//		|		return d;
+		//		|	}
+		//
+		//		|	// using Deferred style
+		//		|	renderLotsOfData(someDataObj).then(null, function(){
+		//		|		promptUserToRecover();
+		//		|	});
+		//
+		//		Note that the caller doesn't have to change his code at all to
+		//		handle the asynchronous case.
+
+		var result, finished, isError, head, nextListener;
+		var promise = (this.promise = {});
+
+		function complete(value){
+			if(finished){
+				throw new Error("This deferred has already been resolved");
+			}
+			result = value;
+			finished = true;
+			notify();
+		}
+		function notify(){
+			var mutated;
+			while(!mutated && nextListener){
+				var listener = nextListener;
+				nextListener = nextListener.next;
+				if((mutated = (listener.progress == mutator))){ // assignment and check
+					finished = false;
+				}
+				var func = (isError ? listener.error : listener.resolved);
+				if(func){
+					try{
+						var newResult = func(result);
+						if (newResult && typeof newResult.then === "function"){
+							newResult.then(lang.hitch(listener.deferred, "resolve"), lang.hitch(listener.deferred, "reject"), lang.hitch(listener.deferred, "progress"));
+							continue;
+						}
+						var unchanged = mutated && newResult === undefined;
+						if(mutated && !unchanged){
+							isError = newResult instanceof Error;
+						}
+						listener.deferred[unchanged && isError ? "reject" : "resolve"](unchanged ? result : newResult);
+					}catch(e){
+						listener.deferred.reject(e);
+					}
+				}else{
+					if(isError){
+						listener.deferred.reject(result);
+					}else{
+						listener.deferred.resolve(result);
+					}
+				}
+			}
+		}
+		// calling resolve will resolve the promise
+		this.resolve = this.callback = function(value){
+			// summary:
+			//		Fulfills the Deferred instance successfully with the provide value
+			this.fired = 0;
+			this.results = [value, null];
+			complete(value);
+		};
+
+
+		// calling error will indicate that the promise failed
+		this.reject = this.errback = function(error){
+			// summary:
+			//		Fulfills the Deferred instance as an error with the provided error
+			isError = true;
+			this.fired = 1;
+			complete(error);
+			this.results = [null, error];
+			if(!error || error.log !== false){
+				(dojo.config.deferredOnError || function(x){ console.error(x); })(error);
+			}
+		};
+		// call progress to provide updates on the progress on the completion of the promise
+		this.progress = function(update){
+			// summary:
+			//		Send progress events to all listeners
+			var listener = nextListener;
+			while(listener){
+				var progress = listener.progress;
+				progress && progress(update);
+				listener = listener.next;
+			}
+		};
+		this.addCallbacks = function(callback, errback){
+			// summary:
+			//		Adds callback and error callback for this deferred instance.
+			// callback: Function?
+			// 		The callback attached to this deferred object.
+			// errback: Function?
+			// 		The error callback attached to this deferred object.
+			// returns:
+			// 		Returns this deferred object.
+			this.then(callback, errback, mutator);
+			return this;	// dojo.Deferred
+		};
+		// provide the implementation of the promise
+		promise.then = this.then = function(/*Function?*/resolvedCallback, /*Function?*/errorCallback, /*Function?*/progressCallback){
+			// summary:
+			//		Adds a fulfilledHandler, errorHandler, and progressHandler to be called for
+			//		completion of a promise. The fulfilledHandler is called when the promise
+			//		is fulfilled. The errorHandler is called when a promise fails. The
+			//		progressHandler is called for progress events. All arguments are optional
+			//		and non-function values are ignored. The progressHandler is not only an
+			//		optional argument, but progress events are purely optional. Promise
+			//		providers are not required to ever create progress events.
+			//
+			//		This function will return a new promise that is fulfilled when the given
+			//		fulfilledHandler or errorHandler callback is finished. This allows promise
+			//		operations to be chained together. The value returned from the callback
+			//		handler is the fulfillment value for the returned promise. If the callback
+			//		throws an error, the returned promise will be moved to failed state.
+			//
+			// returns: 
+			//		Returns a new promise that represents the result of the
+			//		execution of the callback. The callbacks will never affect the original promises value.
+			// example:
+			//		An example of using a CommonJS compliant promise:
+			//		|	asyncComputeTheAnswerToEverything().
+			//		|		then(addTwo).
+			//		|		then(printResult, onError);
+			//		|	>44
+			//
+			var returnDeferred = progressCallback == mutator ? this : new dojo.Deferred(promise.cancel);
+			var listener = {
+				resolved: resolvedCallback,
+				error: errorCallback,
+				progress: progressCallback,
+				deferred: returnDeferred
+			};
+			if(nextListener){
+				head = head.next = listener;
+			}
+			else{
+				nextListener = head = listener;
+			}
+			if(finished){
+				notify();
+			}
+			return returnDeferred.promise; // Promise
+		};
+		var deferred = this;
+		promise.cancel = this.cancel = function (){
+			// summary:
+			//		Cancels the asynchronous operation
+			if(!finished){
+				var error = canceller && canceller(deferred);
+				if(!finished){
+					if (!(error instanceof Error)){
+						error = new Error(error);
+					}
+					error.log = false;
+					deferred.reject(error);
+				}
+			}
+		};
+		freeze(promise);
+	};
+	lang.extend(dojo.Deferred, {
+		addCallback: function (/*Function*/ callback){
+			// summary:
+			// 		Adds successful callback for this deferred instance.
+			// returns:
+			// 		Returns this deferred object.
+			return this.addCallbacks(lang.hitch.apply(dojo, arguments));	// dojo.Deferred
+		},
+
+		addErrback: function (/*Function*/ errback){
+			// summary:
+			// 		Adds error callback for this deferred instance.
+			// returns:
+			// 		Returns this deferred object.
+			return this.addCallbacks(null, lang.hitch.apply(dojo, arguments));	// dojo.Deferred
+		},
+
+		addBoth: function (/*Function*/ callback){
+			// summary:
+			// 		Add handler as both successful callback and error callback for this deferred instance.
+			// returns:
+			// 		Returns this deferred object.
+			var enclosed = lang.hitch.apply(dojo, arguments);
+			return this.addCallbacks(enclosed, enclosed);	// dojo.Deferred
+		},
+		fired: -1
+	});
+
+	dojo.Deferred.when = dojo.when = function(promiseOrValue, /*Function?*/ callback, /*Function?*/ errback, /*Function?*/ progressHandler){
+		// summary:
+		//		This provides normalization between normal synchronous values and
+		//		asynchronous promises, so you can interact with them in a common way
+		// returns:
+		// 		Returns a new promise that represents the result of the execution of callback 
+		// 		when parameter "promiseOrValue" is promise.
+		// 		Returns the execution result of callback when parameter "promiseOrValue" is value.
+		// example:
+		//		|	function printFirstAndLast(items){
+		//		|		dojo.when(findFirst(items), console.log);
+		//		|		dojo.when(findLast(items), console.log);
+		//		|	}
+		//		|	function findFirst(items){
+		//		|		return dojo.when(items, function(items){
+		//		|			return items[0];
+		//		|		});
+		//		|	}
+		//		|	function findLast(items){
+		//		|		return dojo.when(items, function(items){
+		//		|			return items[items.length - 1];
+		//		|		});
+		//		|	}
+		//		And now all three of his functions can be used sync or async.
+		//		|	printFirstAndLast([1,2,3,4]) will work just as well as
+		//		|	printFirstAndLast(dojo.xhrGet(...));
+
+		if(promiseOrValue && typeof promiseOrValue.then === "function"){
+			return promiseOrValue.then(callback, errback, progressHandler);
+		}
+		return callback ? callback(promiseOrValue) : promiseOrValue;	// Promise
+	};
+
+	return dojo.Deferred;
+});
diff --git a/lib/dojo/_base/NodeList.js b/lib/dojo/_base/NodeList.js
index 8cdc1c0f7..4fa6b48a0 100644
--- a/lib/dojo/_base/NodeList.js
+++ b/lib/dojo/_base/NodeList.js
@@ -4,1010 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.NodeList"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.NodeList"] = true;
-dojo.provide("dojo._base.NodeList");
-dojo.require("dojo._base.lang");
-dojo.require("dojo._base.array");
-dojo.require("dojo._base.connect");
-dojo.require("dojo._base.html");
-
-
-(function(){
-
-	var d = dojo;
-
-	var ap = Array.prototype, aps = ap.slice, apc = ap.concat;
-
-	var tnl = function(/*Array*/ a, /*dojo.NodeList?*/ parent, /*Function?*/ NodeListCtor){
-		// summary:
-		// 		decorate an array to make it look like a `dojo.NodeList`.
-		// a:
-		// 		Array of nodes to decorate.
-		// parent:
-		// 		An optional parent NodeList that generated the current
-		// 		list of nodes. Used to call _stash() so the parent NodeList
-		// 		can be accessed via end() later.
-		// NodeListCtor:
-		// 		An optional constructor function to use for any
-		// 		new NodeList calls. This allows a certain chain of
-		// 		NodeList calls to use a different object than dojo.NodeList.
-		if(!a.sort){
-			// make sure it's a real array before we pass it on to be wrapped
-			a = aps.call(a, 0);
-		}
-		var ctor = NodeListCtor || this._NodeListCtor || d._NodeListCtor;
-		a.constructor = ctor;
-		dojo._mixin(a, ctor.prototype);
-		a._NodeListCtor = ctor;
-		return parent ? a._stash(parent) : a;
-	};
-
-	var loopBody = function(f, a, o){
-		a = [0].concat(aps.call(a, 0));
-		o = o || d.global;
-		return function(node){
-			a[0] = node;
-			return f.apply(o, a);
-		};
-	};
-
-	// adapters
-
-	var adaptAsForEach = function(f, o){
-		//	summary:
-		//		adapts a single node function to be used in the forEach-type
-		//		actions. The initial object is returned from the specialized
-		//		function.
-		//	f: Function
-		//		a function to adapt
-		//	o: Object?
-		//		an optional context for f
-		return function(){
-			this.forEach(loopBody(f, arguments, o));
-			return this;	// Object
-		};
-	};
-
-	var adaptAsMap = function(f, o){
-		//	summary:
-		//		adapts a single node function to be used in the map-type
-		//		actions. The return is a new array of values, as via `dojo.map`
-		//	f: Function
-		//		a function to adapt
-		//	o: Object?
-		//		an optional context for f
-		return function(){
-			return this.map(loopBody(f, arguments, o));
-		};
-	};
-
-	var adaptAsFilter = function(f, o){
-		//	summary:
-		//		adapts a single node function to be used in the filter-type actions
-		//	f: Function
-		//		a function to adapt
-		//	o: Object?
-		//		an optional context for f
-		return function(){
-			return this.filter(loopBody(f, arguments, o));
-		};
-	};
-
-	var adaptWithCondition = function(f, g, o){
-		//	summary:
-		//		adapts a single node function to be used in the map-type
-		//		actions, behaves like forEach() or map() depending on arguments
-		//	f: Function
-		//		a function to adapt
-		//	g: Function
-		//		a condition function, if true runs as map(), otherwise runs as forEach()
-		//	o: Object?
-		//		an optional context for f and g
-		return function(){
-			var a = arguments, body = loopBody(f, a, o);
-			if(g.call(o || d.global, a)){
-				return this.map(body);	// self
-			}
-			this.forEach(body);
-			return this;	// self
-		};
-	};
-
-	var magicGuard = function(a){
-		//	summary:
-		//		the guard function for dojo.attr() and dojo.style()
-		return a.length == 1 && (typeof a[0] == "string"); // inline'd type check
-	};
-
-	var orphan = function(node){
-		//	summary:
-		//		function to orphan nodes
-		var p = node.parentNode;
-		if(p){
-			p.removeChild(node);
-		}
-	};
-	// FIXME: should we move orphan() to dojo.html?
-
-	dojo.NodeList = function(){
-		//	summary:
-		//		dojo.NodeList is an of Array subclass which adds syntactic
-		//		sugar for chaining, common iteration operations, animation, and
-		//		node manipulation. NodeLists are most often returned as the
-		//		result of dojo.query() calls.
-		//	description:
-		//		dojo.NodeList instances provide many utilities that reflect
-		//		core Dojo APIs for Array iteration and manipulation, DOM
-		//		manipulation, and event handling. Instead of needing to dig up
-		//		functions in the dojo.* namespace, NodeLists generally make the
-		//		full power of Dojo available for DOM manipulation tasks in a
-		//		simple, chainable way.
-		//	example:
-		//		create a node list from a node
-		//		|	new dojo.NodeList(dojo.byId("foo"));
-		//	example:
-		//		get a NodeList from a CSS query and iterate on it
-		//		|	var l = dojo.query(".thinger");
-		//		|	l.forEach(function(node, index, nodeList){
-		//		|		console.log(index, node.innerHTML);
-		//		|	});
-		//	example:
-		//		use native and Dojo-provided array methods to manipulate a
-		//		NodeList without needing to use dojo.* functions explicitly:
-		//		|	var l = dojo.query(".thinger");
-		//		|	// since NodeLists are real arrays, they have a length
-		//		|	// property that is both readable and writable and
-		//		|	// push/pop/shift/unshift methods
-		//		|	console.log(l.length);
-		//		|	l.push(dojo.create("span"));
-		//		|
-		//		|	// dojo's normalized array methods work too:
-		//		|	console.log( l.indexOf(dojo.byId("foo")) );
-		//		|	// ...including the special "function as string" shorthand
-		//		|	console.log( l.every("item.nodeType == 1") );
-		//		|
-		//		|	// NodeLists can be [..] indexed, or you can use the at()
-		//		|	// function to get specific items wrapped in a new NodeList:
-		//		|	var node = l[3]; // the 4th element
-		//		|	var newList = l.at(1, 3); // the 2nd and 4th elements
-		//	example:
-		//		the style functions you expect are all there too:
-		//		|	// style() as a getter...
-		//		|	var borders = dojo.query(".thinger").style("border");
-		//		|	// ...and as a setter:
-		//		|	dojo.query(".thinger").style("border", "1px solid black");
-		//		|	// class manipulation
-		//		|	dojo.query("li:nth-child(even)").addClass("even");
-		//		|	// even getting the coordinates of all the items
-		//		|	var coords = dojo.query(".thinger").coords();
-		//	example:
-		//		DOM manipulation functions from the dojo.* namespace area also
-		//		available:
-		//		|	// remove all of the elements in the list from their
-		//		|	// parents (akin to "deleting" them from the document)
-		//		|	dojo.query(".thinger").orphan();
-		//		|	// place all elements in the list at the front of #foo
-		//		|	dojo.query(".thinger").place("foo", "first");
-		//	example:
-		//		Event handling couldn't be easier. `dojo.connect` is mapped in,
-		//		and shortcut handlers are provided for most DOM events:
-		//		|	// like dojo.connect(), but with implicit scope
-		//		|	dojo.query("li").connect("onclick", console, "log");
-		//		|
-		//		|	// many common event handlers are already available directly:
-		//		|	dojo.query("li").onclick(console, "log");
-		//		|	var toggleHovered = dojo.hitch(dojo, "toggleClass", "hovered");
-		//		|	dojo.query("p")
-		//		|		.onmouseenter(toggleHovered)
-		//		|		.onmouseleave(toggleHovered);
-		//	example:
-		//		chainability is a key advantage of NodeLists:
-		//		|	dojo.query(".thinger")
-		//		|		.onclick(function(e){ /* ... */ })
-		//		|		.at(1, 3, 8) // get a subset
-		//		|			.style("padding", "5px")
-		//		|			.forEach(console.log);
-
-		return tnl(Array.apply(null, arguments));
-	};
-
-	//Allow things that new up a NodeList to use a delegated or alternate NodeList implementation.
-	d._NodeListCtor = d.NodeList;
-
-	var nl = d.NodeList, nlp = nl.prototype;
-
-	// expose adapters and the wrapper as private functions
-
-	nl._wrap = nlp._wrap = tnl;
-	nl._adaptAsMap = adaptAsMap;
-	nl._adaptAsForEach = adaptAsForEach;
-	nl._adaptAsFilter  = adaptAsFilter;
-	nl._adaptWithCondition = adaptWithCondition;
-
-	// mass assignment
-
-	// add array redirectors
-	d.forEach(["slice", "splice"], function(name){
-		var f = ap[name];
-		//Use a copy of the this array via this.slice() to allow .end() to work right in the splice case.
-		// CANNOT apply ._stash()/end() to splice since it currently modifies
-		// the existing this array -- it would break backward compatibility if we copy the array before
-		// the splice so that we can use .end(). So only doing the stash option to this._wrap for slice.
-		nlp[name] = function(){ return this._wrap(f.apply(this, arguments), name == "slice" ? this : null); };
-	});
-	// concat should be here but some browsers with native NodeList have problems with it
-
-	// add array.js redirectors
-	d.forEach(["indexOf", "lastIndexOf", "every", "some"], function(name){
-		var f = d[name];
-		nlp[name] = function(){ return f.apply(d, [this].concat(aps.call(arguments, 0))); };
-	});
-
-	// add conditional methods
-	d.forEach(["attr", "style"], function(name){
-		nlp[name] = adaptWithCondition(d[name], magicGuard);
-	});
-
-	// add forEach actions
-	d.forEach(["connect", "addClass", "removeClass", "replaceClass", "toggleClass", "empty", "removeAttr"], function(name){
-		nlp[name] = adaptAsForEach(d[name]);
-	});
-
-	dojo.extend(dojo.NodeList, {
-		_normalize: function(/*String||Element||Object||NodeList*/content, /*DOMNode?*/refNode){
-			// summary:
-			// 		normalizes data to an array of items to insert.
-			// description:
-			// 		If content is an object, it can have special properties "template" and
-			// 		"parse". If "template" is defined, then the template value is run through
-			// 		dojo.string.substitute (if dojo.string.substitute has been dojo.required elsewhere),
-			// 		or if templateFunc is a function on the content, that function will be used to
-			// 		transform the template into a final string to be used for for passing to dojo._toDom.
-			// 		If content.parse is true, then it is remembered for later, for when the content
-			// 		nodes are inserted into the DOM. At that point, the nodes will be parsed for widgets
-			// 		(if dojo.parser has been dojo.required elsewhere).
-
-			//Wanted to just use a DocumentFragment, but for the array/NodeList
-			//case that meant  using cloneNode, but we may not want that.
-			//Cloning should only happen if the node operations span
-			//multiple refNodes. Also, need a real array, not a NodeList from the
-			//DOM since the node movements could change those NodeLists.
-
-			var parse = content.parse === true ? true : false;
-
-			//Do we have an object that needs to be run through a template?
-			if(typeof content.template == "string"){
-				var templateFunc = content.templateFunc || (dojo.string && dojo.string.substitute);
-				content = templateFunc ? templateFunc(content.template, content) : content;
-			}
-
-			var type = (typeof content);
-			if(type == "string" || type == "number"){
-				content = dojo._toDom(content, (refNode && refNode.ownerDocument));
-				if(content.nodeType == 11){
-					//DocumentFragment. It cannot handle cloneNode calls, so pull out the children.
-					content = dojo._toArray(content.childNodes);
-				}else{
-					content = [content];
-				}
-			}else if(!dojo.isArrayLike(content)){
-				content = [content];
-			}else if(!dojo.isArray(content)){
-				//To get to this point, content is array-like, but
-				//not an array, which likely means a DOM NodeList. Convert it now.
-				content = dojo._toArray(content);
-			}
-
-			//Pass around the parse info
-			if(parse){
-				content._runParse = true;
-			}
-			return content; //Array
-		},
-
-		_cloneNode: function(/*DOMNode*/ node){
-			// summary:
-			// 		private utility to clone a node. Not very interesting in the vanilla
-			// 		dojo.NodeList case, but delegates could do interesting things like
-			// 		clone event handlers if that is derivable from the node.
-			return node.cloneNode(true);
-		},
-
-		_place: function(/*Array*/ary, /*DOMNode*/refNode, /*String*/position, /*Boolean*/useClone){
-			// summary:
-			// 		private utility to handle placing an array of nodes relative to another node.
-			// description:
-			// 		Allows for cloning the nodes in the array, and for
-			// 		optionally parsing widgets, if ary._runParse is true.
-
-			//Avoid a disallowed operation if trying to do an innerHTML on a non-element node.
-			if(refNode.nodeType != 1 && position == "only"){
-				return;
-			}
-			var rNode = refNode, tempNode;
-
-			//Always cycle backwards in case the array is really a
-			//DOM NodeList and the DOM operations take it out of the live collection.
-			var length = ary.length;
-			for(var i = length - 1; i >= 0; i--){
-				var node = (useClone ? this._cloneNode(ary[i]) : ary[i]);
-
-				//If need widget parsing, use a temp node, instead of waiting after inserting into
-				//real DOM because we need to start widget parsing at one node up from current node,
-				//which could cause some already parsed widgets to be parsed again.
-				if(ary._runParse && dojo.parser && dojo.parser.parse){
-					if(!tempNode){
-						tempNode = rNode.ownerDocument.createElement("div");
-					}
-					tempNode.appendChild(node);
-					dojo.parser.parse(tempNode);
-					node = tempNode.firstChild;
-					while(tempNode.firstChild){
-						tempNode.removeChild(tempNode.firstChild);
-					}
-				}
-
-				if(i == length - 1){
-					dojo.place(node, rNode, position);
-				}else{
-					rNode.parentNode.insertBefore(node, rNode);
-				}
-				rNode = node;
-			}
-		},
-
-		_stash: function(parent){
-			// summary:
-			// 		private function to hold to a parent NodeList. end() to return the parent NodeList.
-			//
-			// example:
-			// How to make a `dojo.NodeList` method that only returns the third node in
-			// the dojo.NodeList but allows access to the original NodeList by using this._stash:
-			//	|	dojo.extend(dojo.NodeList, {
-			//	|		third: function(){
-			//  |			var newNodeList = dojo.NodeList(this[2]);
-			//	|			return newNodeList._stash(this);
-			//	|		}
-			//	|	});
-			//	|	// then see how _stash applies a sub-list, to be .end()'ed out of
-			//	|	dojo.query(".foo")
-			//	|		.third()
-			//	|			.addClass("thirdFoo")
-			//	|		.end()
-			//	|		// access to the orig .foo list
-			//	|		.removeClass("foo")
-			//	|
-			//
-			this._parent = parent;
-			return this; //dojo.NodeList
-		},
-
-		end: function(){
-			// summary:
-			// 		Ends use of the current `dojo.NodeList` by returning the previous dojo.NodeList
-			// 		that generated the current dojo.NodeList.
-			// description:
-			// 		Returns the `dojo.NodeList` that generated the current `dojo.NodeList`. If there
-			// 		is no parent dojo.NodeList, an empty dojo.NodeList is returned.
-			// example:
-			//	|	dojo.query("a")
-			//	|		.filter(".disabled")
-			//	|			// operate on the anchors that only have a disabled class
-			//	|			.style("color", "grey")
-			//	|		.end()
-			//	|		// jump back to the list of anchors
-			//	|		.style(...)
-			//
-			if(this._parent){
-				return this._parent;
-			}else{
-				//Just return empty list.
-				return new this._NodeListCtor();
-			}
-		},
-
-		// http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array#Methods
-
-		// FIXME: handle return values for #3244
-		//		http://trac.dojotoolkit.org/ticket/3244
-
-		// FIXME:
-		//		need to wrap or implement:
-		//			join (perhaps w/ innerHTML/outerHTML overload for toString() of items?)
-		//			reduce
-		//			reduceRight
-
-		/*=====
-		slice: function(begin, end){
-			// summary:
-			//		Returns a new NodeList, maintaining this one in place
-			// description:
-			//		This method behaves exactly like the Array.slice method
-			//		with the caveat that it returns a dojo.NodeList and not a
-			//		raw Array. For more details, see Mozilla's (slice
-			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:slice]
-			// begin: Integer
-			//		Can be a positive or negative integer, with positive
-			//		integers noting the offset to begin at, and negative
-			//		integers denoting an offset from the end (i.e., to the left
-			//		of the end)
-			// end: Integer?
-			//		Optional parameter to describe what position relative to
-			//		the NodeList's zero index to end the slice at. Like begin,
-			//		can be positive or negative.
-			return this._wrap(a.slice.apply(this, arguments));
-		},
-
-		splice: function(index, howmany, item){
-			// summary:
-			//		Returns a new NodeList, manipulating this NodeList based on
-			//		the arguments passed, potentially splicing in new elements
-			//		at an offset, optionally deleting elements
-			// description:
-			//		This method behaves exactly like the Array.splice method
-			//		with the caveat that it returns a dojo.NodeList and not a
-			//		raw Array. For more details, see Mozilla's (splice
-			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:splice]
-			// 		For backwards compatibility, calling .end() on the spliced NodeList
-			// 		does not return the original NodeList -- splice alters the NodeList in place.
-			// index: Integer
-			//		begin can be a positive or negative integer, with positive
-			//		integers noting the offset to begin at, and negative
-			//		integers denoting an offset from the end (i.e., to the left
-			//		of the end)
-			// howmany: Integer?
-			//		Optional parameter to describe what position relative to
-			//		the NodeList's zero index to end the slice at. Like begin,
-			//		can be positive or negative.
-			// item: Object...?
-			//		Any number of optional parameters may be passed in to be
-			//		spliced into the NodeList
-			// returns:
-			//		dojo.NodeList
-			return this._wrap(a.splice.apply(this, arguments));
-		},
-
-		indexOf: function(value, fromIndex){
-			//	summary:
-			//		see dojo.indexOf(). The primary difference is that the acted-on
-			//		array is implicitly this NodeList
-			// value: Object:
-			//		The value to search for.
-			// fromIndex: Integer?:
-			//		The location to start searching from. Optional. Defaults to 0.
-			//	description:
-			//		For more details on the behavior of indexOf, see Mozilla's
-			//		(indexOf
-			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:indexOf]
-			//	returns:
-			//		Positive Integer or 0 for a match, -1 of not found.
-			return d.indexOf(this, value, fromIndex); // Integer
-		},
-
-		lastIndexOf: function(value, fromIndex){
-			// summary:
-			//		see dojo.lastIndexOf(). The primary difference is that the
-			//		acted-on array is implicitly this NodeList
-			//	description:
-			//		For more details on the behavior of lastIndexOf, see
-			//		Mozilla's (lastIndexOf
-			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:lastIndexOf]
-			// value: Object
-			//		The value to search for.
-			// fromIndex: Integer?
-			//		The location to start searching from. Optional. Defaults to 0.
-			// returns:
-			//		Positive Integer or 0 for a match, -1 of not found.
-			return d.lastIndexOf(this, value, fromIndex); // Integer
-		},
-
-		every: function(callback, thisObject){
-			//	summary:
-			//		see `dojo.every()` and the (Array.every
-			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:every].
-			//		Takes the same structure of arguments and returns as
-			//		dojo.every() with the caveat that the passed array is
-			//		implicitly this NodeList
-			// callback: Function: the callback
-			// thisObject: Object?: the context
-			return d.every(this, callback, thisObject); // Boolean
-		},
-
-		some: function(callback, thisObject){
-			//	summary:
-			//		Takes the same structure of arguments and returns as
-			//		`dojo.some()` with the caveat that the passed array is
-			//		implicitly this NodeList.  See `dojo.some()` and Mozilla's
-			//		(Array.some
-			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some].
-			// callback: Function: the callback
-			// thisObject: Object?: the context
-			return d.some(this, callback, thisObject); // Boolean
-		},
-		=====*/
-
-		concat: function(item){
-			// summary:
-			//		Returns a new NodeList comprised of items in this NodeList
-			//		as well as items passed in as parameters
-			// description:
-			//		This method behaves exactly like the Array.concat method
-			//		with the caveat that it returns a `dojo.NodeList` and not a
-			//		raw Array. For more details, see the (Array.concat
-			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:concat]
-			// item: Object?
-			//		Any number of optional parameters may be passed in to be
-			//		spliced into the NodeList
-			// returns:
-			//		dojo.NodeList
-
-			//return this._wrap(apc.apply(this, arguments));
-			// the line above won't work for the native NodeList :-(
-
-			// implementation notes:
-			// 1) Native NodeList is not an array, and cannot be used directly
-			// in concat() --- the latter doesn't recognize it as an array, and
-			// does not inline it, but append as a single entity.
-			// 2) On some browsers (e.g., Safari) the "constructor" property is
-			// read-only and cannot be changed. So we have to test for both
-			// native NodeList and dojo.NodeList in this property to recognize
-			// the node list.
-
-			var t = d.isArray(this) ? this : aps.call(this, 0),
-				m = d.map(arguments, function(a){
-					return a && !d.isArray(a) &&
-						(typeof NodeList != "undefined" && a.constructor === NodeList || a.constructor === this._NodeListCtor) ?
-							aps.call(a, 0) : a;
-				});
-			return this._wrap(apc.apply(t, m), this);	// dojo.NodeList
-		},
-
-		map: function(/*Function*/ func, /*Function?*/ obj){
-			//	summary:
-			//		see dojo.map(). The primary difference is that the acted-on
-			//		array is implicitly this NodeList and the return is a
-			//		dojo.NodeList (a subclass of Array)
-			///return d.map(this, func, obj, d.NodeList); // dojo.NodeList
-			return this._wrap(d.map(this, func, obj), this); // dojo.NodeList
-		},
-
-		forEach: function(callback, thisObj){
-			//	summary:
-			//		see `dojo.forEach()`. The primary difference is that the acted-on
-			//		array is implicitly this NodeList. If you want the option to break out
-			//		of the forEach loop, use every() or some() instead.
-			d.forEach(this, callback, thisObj);
-			// non-standard return to allow easier chaining
-			return this; // dojo.NodeList
-		},
-
-		/*=====
-		coords: function(){
-			//	summary:
-			//		Returns the box objects of all elements in a node list as
-			//		an Array (*not* a NodeList). Acts like `dojo.coords`, though assumes
-			//		the node passed is each node in this list.
-
-			return d.map(this, d.coords); // Array
-		},
-
-		position: function(){
-			//	summary:
-			//		Returns border-box objects (x/y/w/h) of all elements in a node list
-			//		as an Array (*not* a NodeList). Acts like `dojo.position`, though
-			//		assumes the node passed is each node in this list.
-
-			return d.map(this, d.position); // Array
-		},
-
-		attr: function(property, value){
-			//	summary:
-			//		gets or sets the DOM attribute for every element in the
-			//		NodeList. See also `dojo.attr`
-			//	property: String
-			//		the attribute to get/set
-			//	value: String?
-			//		optional. The value to set the property to
-			//	returns:
-			//		if no value is passed, the result is an array of attribute values
-			//		If a value is passed, the return is this NodeList
-			//	example:
-			//		Make all nodes with a particular class focusable:
-			//	|	dojo.query(".focusable").attr("tabIndex", -1);
-			//	example:
-			//		Disable a group of buttons:
-			//	|	dojo.query("button.group").attr("disabled", true);
-			//	example:
-			//		innerHTML can be assigned or retrieved as well:
-			//	|	// get the innerHTML (as an array) for each list item
-			//	|	var ih = dojo.query("li.replaceable").attr("innerHTML");
-			return; // dojo.NodeList
-			return; // Array
-		},
-
-		style: function(property, value){
-			//	summary:
-			//		gets or sets the CSS property for every element in the NodeList
-			//	property: String
-			//		the CSS property to get/set, in JavaScript notation
-			//		("lineHieght" instead of "line-height")
-			//	value: String?
-			//		optional. The value to set the property to
-			//	returns:
-			//		if no value is passed, the result is an array of strings.
-			//		If a value is passed, the return is this NodeList
-			return; // dojo.NodeList
-			return; // Array
-		},
-
-		addClass: function(className){
-			//	summary:
-			//		adds the specified class to every node in the list
-			//	className: String|Array
-			//		A String class name to add, or several space-separated class names,
-			//		or an array of class names.
-			return; // dojo.NodeList
-		},
-
-		removeClass: function(className){
-			//	summary:
-			//		removes the specified class from every node in the list
-			//	className: String|Array?
-			//		An optional String class name to remove, or several space-separated
-			//		class names, or an array of class names. If omitted, all class names
-			//		will be deleted.
-			//	returns:
-			//		dojo.NodeList, this list
-			return; // dojo.NodeList
-		},
-
-		toggleClass: function(className, condition){
-			//	summary:
-			//		Adds a class to node if not present, or removes if present.
-			//		Pass a boolean condition if you want to explicitly add or remove.
-			//	condition: Boolean?
-			//		If passed, true means to add the class, false means to remove.
-			//	className: String
-			//		the CSS class to add
-			return; // dojo.NodeList
-		},
-
-		connect: function(methodName, objOrFunc, funcName){
-			//	summary:
-			//		attach event handlers to every item of the NodeList. Uses dojo.connect()
-			//		so event properties are normalized
-			//	methodName: String
-			//		the name of the method to attach to. For DOM events, this should be
-			//		the lower-case name of the event
-			//	objOrFunc: Object|Function|String
-			//		if 2 arguments are passed (methodName, objOrFunc), objOrFunc should
-			//		reference a function or be the name of the function in the global
-			//		namespace to attach. If 3 arguments are provided
-			//		(methodName, objOrFunc, funcName), objOrFunc must be the scope to
-			//		locate the bound function in
-			//	funcName: String?
-			//		optional. A string naming the function in objOrFunc to bind to the
-			//		event. May also be a function reference.
-			//	example:
-			//		add an onclick handler to every button on the page
-			//		|	dojo.query("div:nth-child(odd)").connect("onclick", function(e){
-			//		|		console.log("clicked!");
-			//		|	});
-			// example:
-			//		attach foo.bar() to every odd div's onmouseover
-			//		|	dojo.query("div:nth-child(odd)").connect("onmouseover", foo, "bar");
-		},
-
-		empty: function(){
-			//	summary:
-			//		clears all content from each node in the list. Effectively
-			//		equivalent to removing all child nodes from every item in
-			//		the list.
-			return this.forEach("item.innerHTML='';"); // dojo.NodeList
-			// FIXME: should we be checking for and/or disposing of widgets below these nodes?
-		},
-		=====*/
-
-		// useful html methods
-		coords:	adaptAsMap(d.coords),
-		position: adaptAsMap(d.position),
-
-		// FIXME: connectPublisher()? connectRunOnce()?
-
-		/*
-		destroy: function(){
-			//	summary:
-			//		destroys every item in 	the list.
-			this.forEach(d.destroy);
-			// FIXME: should we be checking for and/or disposing of widgets below these nodes?
-		},
-		*/
-
-		place: function(/*String||Node*/ queryOrNode, /*String*/ position){
-			//	summary:
-			//		places elements of this node list relative to the first element matched
-			//		by queryOrNode. Returns the original NodeList. See: `dojo.place`
-			//	queryOrNode:
-			//		may be a string representing any valid CSS3 selector or a DOM node.
-			//		In the selector case, only the first matching element will be used
-			//		for relative positioning.
-			//	position:
-			//		can be one of:
-			//		|	"last" (default)
-			//		|	"first"
-			//		|	"before"
-			//		|	"after"
-			//		|	"only"
-			//		|	"replace"
-			// 		or an offset in the childNodes property
-			var item = d.query(queryOrNode)[0];
-			return this.forEach(function(node){ d.place(node, item, position); }); // dojo.NodeList
-		},
-
-		orphan: function(/*String?*/ filter){
-			//	summary:
-			//		removes elements in this list that match the filter
-			//		from their parents and returns them as a new NodeList.
-			//	filter:
-			//		CSS selector like ".foo" or "div > span"
-			//	returns:
-			//		`dojo.NodeList` containing the orphaned elements
-			return (filter ? d._filterQueryResult(this, filter) : this).forEach(orphan); // dojo.NodeList
-		},
-
-		adopt: function(/*String||Array||DomNode*/ queryOrListOrNode, /*String?*/ position){
-			//	summary:
-			//		places any/all elements in queryOrListOrNode at a
-			//		position relative to the first element in this list.
-			//		Returns a dojo.NodeList of the adopted elements.
-			//	queryOrListOrNode:
-			//		a DOM node or a query string or a query result.
-			//		Represents the nodes to be adopted relative to the
-			//		first element of this NodeList.
-			//	position:
-			//		can be one of:
-			//		|	"last" (default)
-			//		|	"first"
-			//		|	"before"
-			//		|	"after"
-			//		|	"only"
-			//		|	"replace"
-			// 		or an offset in the childNodes property
-			return d.query(queryOrListOrNode).place(this[0], position)._stash(this);	// dojo.NodeList
-		},
-
-		// FIXME: do we need this?
-		query: function(/*String*/ queryStr){
-			//	summary:
-			//		Returns a new list whose members match the passed query,
-			//		assuming elements of the current NodeList as the root for
-			//		each search.
-			//	example:
-			//		assume a DOM created by this markup:
-			//	|	<div id="foo">
-			//	|		<p>
-			//	|			bacon is tasty, <span>dontcha think?</span>
-			//	|		</p>
-			//	|	</div>
-			//	|	<div id="bar">
-			//	|		<p>great comedians may not be funny <span>in person</span></p>
-			//	|	</div>
-			//		If we are presented with the following definition for a NodeList:
-			//	|	var l = new dojo.NodeList(dojo.byId("foo"), dojo.byId("bar"));
-			//		it's possible to find all span elements under paragraphs
-			//		contained by these elements with this sub-query:
-			//	| 	var spans = l.query("p span");
-
-			// FIXME: probably slow
-			if(!queryStr){ return this; }
-			var ret = this.map(function(node){
-				// FIXME: why would we ever get undefined here?
-				return d.query(queryStr, node).filter(function(subNode){ return subNode !== undefined; });
-			});
-			return this._wrap(apc.apply([], ret), this);	// dojo.NodeList
-		},
-
-		filter: function(/*String|Function*/ filter){
-			//	summary:
-			// 		"masks" the built-in javascript filter() method (supported
-			// 		in Dojo via `dojo.filter`) to support passing a simple
-			// 		string filter in addition to supporting filtering function
-			// 		objects.
-			//	filter:
-			//		If a string, a CSS rule like ".thinger" or "div > span".
-			//	example:
-			//		"regular" JS filter syntax as exposed in dojo.filter:
-			//		|	dojo.query("*").filter(function(item){
-			//		|		// highlight every paragraph
-			//		|		return (item.nodeName == "p");
-			//		|	}).style("backgroundColor", "yellow");
-			// example:
-			//		the same filtering using a CSS selector
-			//		|	dojo.query("*").filter("p").styles("backgroundColor", "yellow");
-
-			var a = arguments, items = this, start = 0;
-			if(typeof filter == "string"){ // inline'd type check
-				items = d._filterQueryResult(this, a[0]);
-				if(a.length == 1){
-					// if we only got a string query, pass back the filtered results
-					return items._stash(this); // dojo.NodeList
-				}
-				// if we got a callback, run it over the filtered items
-				start = 1;
-			}
-			return this._wrap(d.filter(items, a[start], a[start + 1]), this);	// dojo.NodeList
-		},
-
-		/*
-		// FIXME: should this be "copyTo" and include parenting info?
-		clone: function(){
-			// summary:
-			//		creates node clones of each element of this list
-			//		and returns a new list containing the clones
-		},
-		*/
-
-		addContent: function(/*String||DomNode||Object||dojo.NodeList*/ content, /*String||Integer?*/ position){
-			//	summary:
-			//		add a node, NodeList or some HTML as a string to every item in the
-			//		list.  Returns the original list.
-			//	description:
-			//		a copy of the HTML content is added to each item in the
-			//		list, with an optional position argument. If no position
-			//		argument is provided, the content is appended to the end of
-			//		each item.
-			//	content:
-			//		DOM node, HTML in string format, a NodeList or an Object. If a DOM node or
-			// 		NodeList, the content will be cloned if the current NodeList has more than one
-			// 		element. Only the DOM nodes are cloned, no event handlers. If it is an Object,
-			// 		it should be an object with at "template" String property that has the HTML string
-			// 		to insert. If dojo.string has already been dojo.required, then dojo.string.substitute
-			// 		will be used on the "template" to generate the final HTML string. Other allowed
-			// 		properties on the object are: "parse" if the HTML
-			// 		string should be parsed for widgets (dojo.require("dojo.parser") to get that
-			// 		option to work), and "templateFunc" if a template function besides dojo.string.substitute
-			// 		should be used to transform the "template".
-			//	position:
-			//		can be one of:
-			//		|	"last"||"end" (default)
-			//		|	"first||"start"
-			//		|	"before"
-			//		|	"after"
-			//		|	"replace" (replaces nodes in this NodeList with new content)
-			//		|	"only" (removes other children of the nodes so new content is the only child)
-			// 		or an offset in the childNodes property
-			//	example:
-			//		appends content to the end if the position is omitted
-			//	|	dojo.query("h3 > p").addContent("hey there!");
-			//	example:
-			//		add something to the front of each element that has a
-			//		"thinger" property:
-			//	|	dojo.query("[thinger]").addContent("...", "first");
-			//	example:
-			//		adds a header before each element of the list
-			//	|	dojo.query(".note").addContent("<h4>NOTE:</h4>", "before");
-			//	example:
-			//		add a clone of a DOM node to the end of every element in
-			//		the list, removing it from its existing parent.
-			//	|	dojo.query(".note").addContent(dojo.byId("foo"));
-			//  example:
-			//  	Append nodes from a templatized string.
-			// 		dojo.require("dojo.string");
-			// 		dojo.query(".note").addContent({
-			//  		template: '<b>${id}: </b><span>${name}</span>',
-			// 			id: "user332",
-			//  		name: "Mr. Anderson"
-			//  	});
-			//  example:
-			//  	Append nodes from a templatized string that also has widgets parsed.
-			//  	dojo.require("dojo.string");
-			//  	dojo.require("dojo.parser");
-			//  	var notes = dojo.query(".note").addContent({
-			//  		template: '<button dojoType="dijit.form.Button">${text}</button>',
-			//  		parse: true,
-			//  		text: "Send"
-			//  	});
-			content = this._normalize(content, this[0]);
-			for(var i = 0, node; (node = this[i]); i++){
-				this._place(content, node, position, i > 0);
-			}
-			return this; //dojo.NodeList
-		},
-
-		instantiate: function(/*String|Object*/ declaredClass, /*Object?*/ properties){
-			//	summary:
-			//		Create a new instance of a specified class, using the
-			//		specified properties and each node in the nodeList as a
-			//		srcNodeRef.
-			//	example:
-			//		Grabs all buttons in the page and converts them to diji.form.Buttons.
-			//	|	var buttons = dojo.query("button").instantiate("dijit.form.Button", {showLabel: true});
-			var c = d.isFunction(declaredClass) ? declaredClass : d.getObject(declaredClass);
-			properties = properties || {};
-			return this.forEach(function(node){
-				new c(properties, node);
-			});	// dojo.NodeList
-		},
-
-		at: function(/*===== index =====*/){
-			//	summary:
-			//		Returns a new NodeList comprised of items in this NodeList
-			//		at the given index or indices.
-			//
-			//	index: Integer...
-			//		One or more 0-based indices of items in the current
-			//		NodeList. A negative index will start at the end of the
-			//		list and go backwards.
-			//
-			//	example:
-			//	Shorten the list to the first, second, and third elements
-			//	|	dojo.query("a").at(0, 1, 2).forEach(fn);
-			//
-			//	example:
-			//	Retrieve the first and last elements of a unordered list:
-			//	|	dojo.query("ul > li").at(0, -1).forEach(cb);
-			//
-			//	example:
-			//	Do something for the first element only, but end() out back to
-			//	the original list and continue chaining:
-			//	|	dojo.query("a").at(0).onclick(fn).end().forEach(function(n){
-			//	|		console.log(n); // all anchors on the page.
-			//	|	})
-			//
-			//	returns:
-			//		dojo.NodeList
-			var t = new this._NodeListCtor();
-			d.forEach(arguments, function(i){
-				if(i < 0){ i = this.length + i }
-				if(this[i]){ t.push(this[i]); }
-			}, this);
-			return t._stash(this); // dojo.NodeList
-		}
-
-	});
-
-	nl.events = [
-		// summary:
-		//		list of all DOM events used in NodeList
-		"blur", "focus", "change", "click", "error", "keydown", "keypress",
-		"keyup", "load", "mousedown", "mouseenter", "mouseleave", "mousemove",
-		"mouseout", "mouseover", "mouseup", "submit"
-	];
-	
-	// FIXME: pseudo-doc the above automatically generated on-event functions
-
-	// syntactic sugar for DOM events
-	d.forEach(nl.events, function(evt){
-			var _oe = "on" + evt;
-			nlp[_oe] = function(a, b){
-				return this.connect(_oe, a, b);
-			};
-				// FIXME: should these events trigger publishes?
-				/*
-				return (a ? this.connect(_oe, a, b) :
-							this.forEach(function(n){
-								// FIXME:
-								//		listeners get buried by
-								//		addEventListener and can't be dug back
-								//		out to be triggered externally.
-								// see:
-								//		http://developer.mozilla.org/en/docs/DOM:element
-
-								console.log(n, evt, _oe);
-
-								// FIXME: need synthetic event support!
-								var _e = { target: n, faux: true, type: evt };
-								// dojo._event_listener._synthesizeEvent({}, { target: n, faux: true, type: evt });
-								try{ n[evt](_e); }catch(e){ console.log(e); }
-								try{ n[_oe](_e); }catch(e){ console.log(e); }
-							})
-				);
-				*/
-		}
-	);
-
-})();
-
-}
+//>>built
+define("dojo/_base/NodeList",["./kernel","../query","./array","./html","../NodeList-dom"],function(_1,_2,_3){var _4=_2.NodeList;var _5=_4.prototype;_5.connect=_4._adaptAsForEach(function(){return _1.connect.apply(this,arguments);});_5.coords=_4._adaptAsMap(_1.coords);_4.events=["blur","focus","change","click","error","keydown","keypress","keyup","load","mousedown","mouseenter","mouseleave","mousemove","mouseout","mouseover","mouseup","submit"];_3.forEach(_4.events,function(_6){var _7="on"+_6;_5[_7]=function(a,b){return this.connect(_7,a,b);};});_1.NodeList=_4;return _1.NodeList;});
\ No newline at end of file
diff --git a/lib/dojo/_base/NodeList.js.uncompressed.js b/lib/dojo/_base/NodeList.js.uncompressed.js
new file mode 100644
index 000000000..e723fa801
--- /dev/null
+++ b/lib/dojo/_base/NodeList.js.uncompressed.js
@@ -0,0 +1,100 @@
+define("dojo/_base/NodeList", ["./kernel", "../query", "./array", "./html", "../NodeList-dom"], function(dojo, query, array){
+  //  module:
+  //    dojo/_base/NodeList
+  //  summary:
+  //    This module defines dojo.NodeList.
+ 
+var NodeList = query.NodeList;
+
+	/*=====
+	dojo.extend(dojo.NodeList, {
+		connect: function(methodName, objOrFunc, funcName){
+			// summary:
+			//		attach event handlers to every item of the NodeList. Uses dojo.connect()
+			//		so event properties are normalized
+			// methodName: String
+			//		the name of the method to attach to. For DOM events, this should be
+			//		the lower-case name of the event
+			// objOrFunc: Object|Function|String
+			//		if 2 arguments are passed (methodName, objOrFunc), objOrFunc should
+			//		reference a function or be the name of the function in the global
+			//		namespace to attach. If 3 arguments are provided
+			//		(methodName, objOrFunc, funcName), objOrFunc must be the scope to
+			//		locate the bound function in
+			// funcName: String?
+			//		optional. A string naming the function in objOrFunc to bind to the
+			//		event. May also be a function reference.
+			// example:
+			//		add an onclick handler to every button on the page
+			//		|	dojo.query("div:nth-child(odd)").connect("onclick", function(e){
+			//		|		console.log("clicked!");
+			//		|	});
+			// example:
+			//		attach foo.bar() to every odd div's onmouseover
+			//		|	dojo.query("div:nth-child(odd)").connect("onmouseover", foo, "bar");
+		},
+		coords: function(){
+			// summary:
+			//		Deprecated: Use position() for border-box x/y/w/h
+			//		or marginBox() for margin-box w/h/l/t.
+			//		Returns the box objects of all elements in a node list as
+			//		an Array (*not* a NodeList). Acts like `dojo.coords`, though assumes
+			//		the node passed is each node in this list.
+
+			return dojo.map(this, dojo.coords); // Array
+		}
+	 });
+
+	 var NodeList = dojo.NodeList;
+	=====*/
+	var nlp = NodeList.prototype;
+
+	// don't bind early to dojo.connect since we no longer explicitly depend on it
+	nlp.connect = NodeList._adaptAsForEach(function(){
+		return dojo.connect.apply(this, arguments);
+	});
+	nlp.coords = NodeList._adaptAsMap(dojo.coords);
+
+	NodeList.events = [
+		// summary:
+		//		list of all DOM events used in NodeList
+		"blur", "focus", "change", "click", "error", "keydown", "keypress",
+		"keyup", "load", "mousedown", "mouseenter", "mouseleave", "mousemove",
+		"mouseout", "mouseover", "mouseup", "submit"
+	];
+
+	// FIXME: pseudo-doc the above automatically generated on-event functions
+
+	// syntactic sugar for DOM events
+	array.forEach(NodeList.events, function(evt){
+			var _oe = "on" + evt;
+			nlp[_oe] = function(a, b){
+				return this.connect(_oe, a, b);
+			};
+				// FIXME: should these events trigger publishes?
+				/*
+				return (a ? this.connect(_oe, a, b) :
+							this.forEach(function(n){
+								// FIXME:
+								//		listeners get buried by
+								//		addEventListener and can't be dug back
+								//		out to be triggered externally.
+								// see:
+								//		http://developer.mozilla.org/en/docs/DOM:element
+
+								console.log(n, evt, _oe);
+
+								// FIXME: need synthetic event support!
+								var _e = { target: n, faux: true, type: evt };
+								// dojo._event_listener._synthesizeEvent({}, { target: n, faux: true, type: evt });
+								try{ n[evt](_e); }catch(e){ console.log(e); }
+								try{ n[_oe](_e); }catch(e){ console.log(e); }
+							})
+				);
+				*/
+		}
+	);
+
+	dojo.NodeList = NodeList;
+	return dojo.NodeList;
+});
diff --git a/lib/dojo/_base/_loader/bootstrap.js b/lib/dojo/_base/_loader/bootstrap.js
deleted file mode 100644
index a1f99276a..000000000
--- a/lib/dojo/_base/_loader/bootstrap.js
+++ /dev/null
@@ -1,505 +0,0 @@
-/*
-	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
-*/
-
-
-/*=====
-// note:
-//		'djConfig' 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.
-
-djConfig = {
-	// summary:
-	//		Application code can set the global 'djConfig' prior to loading
-	//		the library to override 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,
-	// debugAtAllCosts: Boolean
-	//		Defaults to `false`. If set to `true`, this triggers an alternate
-	//		mode of the package system in which dependencies are detected and
-	//		only then are resources evaluated in dependency order via
-	//		`<script>` tag inclusion. This may double-request resources and
-	//		cause problems with scripts which expect `dojo.require()` to
-	//		preform synchronously. `debugAtAllCosts` can be an invaluable
-	//		debugging aid, but when using it, ensure that all code which
-	//		depends on Dojo modules is wrapped in `dojo.addOnLoad()` handlers.
-	//		Due to the somewhat unpredictable side-effects of using
-	//		`debugAtAllCosts`, it is strongly recommended that you enable this
-	//		flag as a last resort. `debugAtAllCosts` has no effect when loading
-	//		resources across domains. For usage information, see the
-	//		[Dojo Book](http://dojotoolkit.org/book/book-dojo/part-4-meta-dojo-making-your-dojo-code-run-faster-and-better/debugging-facilities/deb)
-	debugAtAllCosts: 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
-}
-=====*/
-
-(function(){
-	// firebug stubs
-
-	if(typeof this["loadFirebugConsole"] == "function"){
-		// for Firebug 1.2
-		this["loadFirebugConsole"]();
-	}else{
-		this.console = this.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 i = 0, tn;
-		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;
-				})();
-			}
-		}
-	}
-
-	//TODOC:  HOW TO DOC THIS?
-	// dojo is the root variable of (almost all) our public symbols -- make sure it is defined.
-	if(typeof dojo == "undefined"){
-		dojo = {
-			_scopeName: "dojo",
-			_scopePrefix: "",
-			_scopePrefixArgs: "",
-			_scopeSuffix: "",
-			_scopeMap: {},
-			_scopeMapRev: {}
-		};
-	}
-
-	var d = dojo;
-
-	//Need placeholders for dijit and dojox for scoping code.
-	if(typeof dijit == "undefined"){
-		dijit = {_scopeName: "dijit"};
-	}
-	if(typeof dojox == "undefined"){
-		dojox = {_scopeName: "dojox"};
-	}
-
-	if(!d._scopeArgs){
-		d._scopeArgs = [dojo, dijit, dojox];
-	}
-
-/*=====
-dojo.global = {
-	//	summary:
-	//		Alias for the global scope
-	//		(e.g. the window object in a browser).
-	//	description:
-	//		Refer to 'dojo.global' rather than referring to window to ensure your
-	//		code runs correctly in contexts other than web browsers (e.g. Rhino on a server).
-}
-=====*/
-	d.global = this;
-
-	d.config =/*===== djConfig = =====*/{
-		isDebug: false,
-		debugAtAllCosts: false
-	};
-
-	// FIXME: 2.0, drop djConfig support. Use dojoConfig exclusively for global config.
-	var cfg = typeof djConfig != "undefined" ? djConfig :
-		typeof dojoConfig != "undefined" ? dojoConfig : null;
-		
-	if(cfg){
-		for(var c in cfg){
-			d.config[c] = cfg[c];
-		}
-	}
-
-/*=====
-	// Override locale setting, if specified
-	dojo.locale = {
-		// summary: the locale as defined by Dojo (read-only)
-	};
-=====*/
-	dojo.locale = d.config.locale;
-
-	var rev = "$Rev: 24595 $".match(/\d+/);
-
-/*=====
-	dojo.version = function(){
-		// summary:
-		//		Version number of the Dojo Toolkit
-		// 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
-		this.major = 0;
-		this.minor = 0;
-		this.patch = 0;
-		this.flag = "";
-		this.revision = 0;
-	}
-=====*/
-	dojo.version = {
-		major: 1, minor: 6, patch: 1, flag: "",
-		revision: rev ? +rev[0] : NaN,
-		toString: function(){
-			with(d.version){
-				return major + "." + minor + "." + patch + flag + " (" + revision + ")";	// String
-			}
-		}
-	}
-
-		// Register with the OpenAjax hub
-	if(typeof OpenAjax != "undefined"){
-		OpenAjax.hub.registerLibrary(dojo._scopeName, "http://dojotoolkit.org", d.version.toString());
-	}
-	
-	var extraNames, extraLen, empty = {};
-	for(var i in {toString: 1}){ extraNames = []; break; }
-	dojo._extraNames = extraNames = extraNames || ["hasOwnProperty", "valueOf", "isPrototypeOf",
-		"propertyIsEnumerable", "toLocaleString", "toString", "constructor"];
-	extraLen = extraNames.length;
-
-	dojo._mixin = function(/*Object*/ target, /*Object*/ source){
-		// summary:
-		//		Adds all properties and methods of source to target. This addition
-		//		is "prototype extension safe", so that instances of objects
-		//		will not pass along prototype defaults.
-		var name, s, i;
-		for(name in source){
-			// the "tobj" condition avoid copying properties in "source"
-			// inherited from Object.prototype.  For example, if target 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 target) || (target[name] !== s && (!(name in empty) || empty[name] !== s))){
-				target[name] = s;
-			}
-		}
-				// IE doesn't recognize some custom functions in for..in
-		if(extraLen && source){
-			for(i = 0; i < extraLen; ++i){
-				name = extraNames[i];
-				s = source[name];
-				if(!(name in target) || (target[name] !== s && (!(name in empty) || empty[name] !== s))){
-					target[name] = s;
-				}
-			}
-		}
-				return target; // Object
-	}
-
-	dojo.mixin = function(/*Object*/obj, /*Object...*/props){
-		// summary:
-		//		Adds all properties and methods of props to obj and returns the
-		//		(now modified) obj.
-		//	description:
-		//		`dojo.mixin` can mix multiple source objects into a
-		//		destination object which is then returned. Unlike regular
-		//		`for...in` iteration, `dojo.mixin` is also smart about avoiding
-		//		extensions which other toolkits may unwisely add to the root
-		//		object prototype
-		//	obj:
-		//		The object to mix properties into. Also the return value.
-		//	props:
-		//		One or more objects whose values are successively copied into
-		//		obj. If more than one of these objects contain the same value,
-		//		the one specified last in the function call will "win".
-		//	example:
-		//		make a shallow copy of an object
-		//	|	var copy = dojo.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 `dojo.mixin` on the `this` object:
-		//	|	dojo.declare("acme.Base", null, {
-		//	|		constructor: function(properties){
-		//	|			// property configuration:
-		//	|			dojo.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 = dojo.mixin(
-		//	|		{
-		//	|			name: "Frylock",
-		//	|			braces: true
-		//	|		},
-		//	|		{
-		//	|			name: "Carl Brutanananadilewski"
-		//	|		}
-		//	|	);
-		//	|
-		//	|	// will print "Carl Brutanananadilewski"
-		//	|	console.log(flattened.name);
-		//	|	// will print "true"
-		//	|	console.log(flattened.braces);
-		if(!obj){ obj = {}; }
-		for(var i=1, l=arguments.length; i<l; i++){
-			d._mixin(obj, arguments[i]);
-		}
-		return obj; // Object
-	}
-
-	dojo._getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){
-		var obj=context || d.global;
-		for(var i=0, p; obj && (p=parts[i]); i++){
-			if(i == 0 && d._scopeMap[p]){
-				p = d._scopeMap[p];
-			}
-			obj = (p in obj ? obj[p] : (create ? obj[p]={} : undefined));
-		}
-		return obj; // mixed
-	}
-
-	dojo.setObject = function(/*String*/name, /*Object*/value, /*Object?*/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:
-		//		Path to a property, in the form "A.B.C".
-		//	context:
-		//		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:
-		//	|	dojo.setObject("foo.bar.baz", value);
-		//	example:
-		//		without `dojo.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";
-		//		wheras with `dojo.setObject`, we can shorten that to:
-		//	|	dojo.setObject("parent.child.prop", "some value", obj);
-		var parts=name.split("."), p=parts.pop(), obj=d._getProp(parts, true, context);
-		return obj && p ? (obj[p]=value) : undefined; // Object
-	}
-
-	dojo.getObject = function(/*String*/name, /*Boolean?*/create, /*Object?*/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:
-		//		Path to an property, in the form "A.B.C".
-		//	create:
-		//		Optional. Defaults to `false`. If `true`, Objects will be
-		//		created at any point along the 'path' that is undefined.
-		//	context:
-		//		Optional. Object to use as root of path. Defaults to
-		//		'dojo.global'. Null may be passed.
-		return d._getProp(name.split("."), create, context); // Object
-	}
-
-	dojo.exists = function(/*String*/name, /*Object?*/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:
-		//		Path to an object, in the form "A.B.C".
-		//	obj:
-		//		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
-		//	|	dojo.exists("foo.bar"); // true
-		//	|	dojo.exists("foo.bar.baz"); // false
-		//	|
-		//	|	// search from a particular scope
-		//	|	dojo.exists("bar", foo); // true
-		//	|	dojo.exists("bar.baz", foo); // false
-		return d.getObject(name, false, obj) !== undefined; // Boolean
-	}
-
-	dojo["eval"] = function(/*String*/ scriptFragment){
-		//	summary:
-		//		A legacy method created for use exclusively by internal Dojo methods. Do not use
-		//		this method directly, the behavior of this eval will differ from the normal
-		//		browser eval.
-		//	description:
-		//		Placed in a separate function to minimize size of trapped
-		//		exceptions. Calling eval() directly from some other scope may
-		//		complicate tracebacks on some platforms.
-		//	returns:
-		//		The result of the evaluation. Often `undefined`
-		return d.global.eval ? d.global.eval(scriptFragment) : eval(scriptFragment); 	// Object
-	}
-
-	/*=====
-		dojo.deprecated = function(behaviour, extra, 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");
-		}
-
-		dojo.experimental = function(moduleName, 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");
-		}
-	=====*/
-
-	//Real functions declared in dojo._firebug.firebug.
-	d.deprecated = d.experimental = function(){};
-
-})();
-// vim:ai:ts=4:noet
diff --git a/lib/dojo/_base/_loader/hostenv_browser.js b/lib/dojo/_base/_loader/hostenv_browser.js
deleted file mode 100644
index b31bd77dc..000000000
--- a/lib/dojo/_base/_loader/hostenv_browser.js
+++ /dev/null
@@ -1,477 +0,0 @@
-/*
-	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
-*/
-
-
-/*=====
-dojo.isBrowser = {
-	//	example:
-	//	|	if(dojo.isBrowser){ ... }
-};
-
-dojo.isFF = {
-	//	example:
-	//	|	if(dojo.isFF > 1){ ... }
-};
-
-dojo.isIE = {
-	// example:
-	//	|	if(dojo.isIE > 6){
-	//	|		// we are IE7
-	// 	|	}
-};
-
-dojo.isSafari = {
-	//	example:
-	//	|	if(dojo.isSafari){ ... }
-	//	example:
-	//		Detect iPhone:
-	//	|	if(dojo.isSafari && navigator.userAgent.indexOf("iPhone") != -1){
-	//	|		// we are iPhone. Note, iPod touch reports "iPod" above and fails this test.
-	//	|	}
-};
-
-dojo = {
-	// isBrowser: Boolean
-	//		True if the client is a web-browser
-	isBrowser: true,
-	//	isFF: Number | undefined
-	//		Version as a Number if client is FireFox. undefined otherwise. Corresponds to
-	//		major detected FireFox version (1.5, 2, 3, etc.)
-	isFF: 2,
-	//	isIE: Number | undefined
-	//		Version as a Number if client is MSIE(PC). undefined otherwise. Corresponds to
-	//		major detected IE version (6, 7, 8, etc.)
-	isIE: 6,
-	//	isKhtml: Number | undefined
-	//		Version as a Number if client is a KHTML browser. undefined otherwise. Corresponds to major
-	//		detected version.
-	isKhtml: 0,
-	//	isWebKit: Number | undefined
-	//		Version as a Number if client is a WebKit-derived browser (Konqueror,
-	//		Safari, Chrome, etc.). undefined otherwise.
-	isWebKit: 0,
-	//	isMozilla: Number | undefined
-	//		Version as a Number if client is a Mozilla-based browser (Firefox,
-	//		SeaMonkey). undefined otherwise. Corresponds to major detected version.
-	isMozilla: 0,
-	//	isOpera: Number | undefined
-	//		Version as a Number if client is Opera. undefined otherwise. Corresponds to
-	//		major detected version.
-	isOpera: 0,
-	//	isSafari: Number | undefined
-	//		Version as a Number if client is Safari or iPhone. undefined otherwise.
-	isSafari: 0,
-	//	isChrome: Number | undefined
-	//		Version as a Number if client is Chrome browser. undefined otherwise.
-	isChrome: 0
-	//	isMac: Boolean
-	//		True if the client runs on Mac
-}
-=====*/
-if(typeof window != 'undefined'){
-	dojo.isBrowser = true;
-	dojo._name = "browser";
-
-
-	// attempt to figure out the path to dojo if it isn't set in the config
-	(function(){
-		var d = dojo;
-
-		// this is a scope protection closure. We set browser versions and grab
-		// the URL we were loaded from here.
-
-		// grab the node we were loaded from
-		if(document && document.getElementsByTagName){
-			var scripts = document.getElementsByTagName("script");
-			var rePkg = /dojo(\.xd)?\.js(\W|$)/i;
-			for(var i = 0; i < scripts.length; i++){
-				var src = scripts[i].getAttribute("src");
-				if(!src){ continue; }
-				var m = src.match(rePkg);
-				if(m){
-					// find out where we came from
-					if(!d.config.baseUrl){
-						d.config.baseUrl = src.substring(0, m.index);
-					}
-					// and find out if we need to modify our behavior
-					var cfg = (scripts[i].getAttribute("djConfig") || scripts[i].getAttribute("data-dojo-config"));
-					if(cfg){
-						var cfgo = eval("({ "+cfg+" })");
-						for(var x in cfgo){
-							dojo.config[x] = cfgo[x];
-						}
-					}
-					break; // "first Dojo wins"
-				}
-			}
-		}
-		d.baseUrl = d.config.baseUrl;
-
-		// fill in the rendering support information in dojo.render.*
-		var n = navigator;
-		var dua = n.userAgent,
-			dav = n.appVersion,
-			tv = parseFloat(dav);
-
-		if(dua.indexOf("Opera") >= 0){ d.isOpera = tv; }
-		if(dua.indexOf("AdobeAIR") >= 0){ d.isAIR = 1; }
-		d.isKhtml = (dav.indexOf("Konqueror") >= 0) ? tv : 0;
-		d.isWebKit = parseFloat(dua.split("WebKit/")[1]) || undefined;
-		d.isChrome = parseFloat(dua.split("Chrome/")[1]) || undefined;
-		d.isMac = dav.indexOf("Macintosh") >= 0;
-
-		// safari detection derived from:
-		//		http://developer.apple.com/internet/safari/faq.html#anchor2
-		//		http://developer.apple.com/internet/safari/uamatrix.html
-		var index = Math.max(dav.indexOf("WebKit"), dav.indexOf("Safari"), 0);
-		if(index && !dojo.isChrome){
-			// try to grab the explicit Safari version first. If we don't get
-			// one, look for less than 419.3 as the indication that we're on something
-			// "Safari 2-ish".
-			d.isSafari = parseFloat(dav.split("Version/")[1]);
-			if(!d.isSafari || parseFloat(dav.substr(index + 7)) <= 419.3){
-				d.isSafari = 2;
-			}
-		}
-
-				if(dua.indexOf("Gecko") >= 0 && !d.isKhtml && !d.isWebKit){ d.isMozilla = d.isMoz = tv; }
-		if(d.isMoz){
-			//We really need to get away from this. Consider a sane isGecko approach for the future.
-			d.isFF = parseFloat(dua.split("Firefox/")[1] || dua.split("Minefield/")[1]) || undefined;
-		}
-		if(document.all && !d.isOpera){
-			d.isIE = parseFloat(dav.split("MSIE ")[1]) || undefined;
-			//In cases where the page has an HTTP header or META tag with
-			//X-UA-Compatible, then it is in emulation mode.
-			//Make sure isIE reflects the desired version.
-			//document.documentMode of 5 means quirks mode.
-			//Only switch the value if documentMode's major version
-			//is different from isIE's major version.
-			var mode = document.documentMode;
-			if(mode && mode != 5 && Math.floor(d.isIE) != mode){
-				d.isIE = mode;
-			}
-		}
-
-		//Workaround to get local file loads of dojo to work on IE 7
-		//by forcing to not use native xhr.
-		if(dojo.isIE && window.location.protocol === "file:"){
-			dojo.config.ieForceActiveXXhr=true;
-		}
-		
-		d.isQuirks = document.compatMode == "BackCompat";
-
-		// TODO: is the HTML LANG attribute relevant?
-		d.locale = dojo.config.locale || (d.isIE ? n.userLanguage : n.language).toLowerCase();
-
-		// These are in order of decreasing likelihood; this will change in time.
-				d._XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];
-		
-		d._xhrObj = function(){
-			// summary:
-			//		does the work of portably generating a new XMLHTTPRequest object.
-			var http, last_e;
-						if(!dojo.isIE || !dojo.config.ieForceActiveXXhr){
-							try{ http = new XMLHttpRequest(); }catch(e){}
-						}
-			if(!http){
-				for(var i=0; i<3; ++i){
-					var progid = d._XMLHTTP_PROGIDS[i];
-					try{
-						http = new ActiveXObject(progid);
-					}catch(e){
-						last_e = e;
-					}
-
-					if(http){
-						d._XMLHTTP_PROGIDS = [progid];  // so faster next time
-						break;
-					}
-				}
-			}
-			
-			if(!http){
-				throw new Error("XMLHTTP not available: "+last_e);
-			}
-
-			return http; // XMLHTTPRequest instance
-		}
-
-		d._isDocumentOk = function(http){
-			var stat = http.status || 0,
-				lp = location.protocol;
-			return (stat >= 200 && stat < 300) || 	// Boolean
-				stat == 304 ||			// allow any 2XX response code
-				stat == 1223 ||			// get it out of the cache
-								// Internet Explorer mangled the status code
-				// Internet Explorer mangled the status code OR we're Titanium/browser chrome/chrome extension requesting a local file
-				(!stat && (lp == "file:" || lp == "chrome:" || lp == "chrome-extension:" || lp == "app:"));
-		}
-
-		//See if base tag is in use.
-		//This is to fix http://trac.dojotoolkit.org/ticket/3973,
-		//but really, we need to find out how to get rid of the dojo._Url reference
-		//below and still have DOH work with the dojo.i18n test following some other
-		//test that uses the test frame to load a document (trac #2757).
-		//Opera still has problems, but perhaps a larger issue of base tag support
-		//with XHR requests (hasBase is true, but the request is still made to document
-		//path, not base path).
-		var owloc = window.location+"";
-		var base = document.getElementsByTagName("base");
-		var hasBase = (base && base.length > 0);
-
-		d._getText = function(/*URI*/ uri, /*Boolean*/ fail_ok){
-			// summary: Read the contents of the specified uri and return those contents.
-			// uri:
-			//		A relative or absolute uri. If absolute, it still must be in
-			//		the same "domain" as we are.
-			// fail_ok:
-			//		Default false. If fail_ok and loading fails, return null
-			//		instead of throwing.
-			// returns: The response text. null is returned when there is a
-			//		failure and failure is okay (an exception otherwise)
-
-			// NOTE: must be declared before scope switches ie. this._xhrObj()
-			var http = d._xhrObj();
-
-			if(!hasBase && dojo._Url){
-				uri = (new dojo._Url(owloc, uri)).toString();
-			}
-
-			if(d.config.cacheBust){
-				//Make sure we have a string before string methods are used on uri
-				uri += "";
-				uri += (uri.indexOf("?") == -1 ? "?" : "&") + String(d.config.cacheBust).replace(/\W+/g,"");
-			}
-
-			http.open('GET', uri, false);
-			try{
-				http.send(null);
-				if(!d._isDocumentOk(http)){
-					var err = Error("Unable to load "+uri+" status:"+ http.status);
-					err.status = http.status;
-					err.responseText = http.responseText;
-					throw err;
-				}
-			}catch(e){
-				if(fail_ok){ return null; } // null
-				// rethrow the exception
-				throw e;
-			}
-			return http.responseText; // String
-		}
-		
-
-		var _w = window;
-		var _handleNodeEvent = function(/*String*/evtName, /*Function*/fp){
-			// summary:
-			//		non-destructively adds the specified function to the node's
-			//		evtName handler.
-			// evtName: should be in the form "onclick" for "onclick" handlers.
-			// Make sure you pass in the "on" part.
-			var _a = _w.attachEvent || _w.addEventListener;
-			evtName = _w.attachEvent ? evtName : evtName.substring(2);
-			_a(evtName, function(){
-				fp.apply(_w, arguments);
-			}, false);
-		};
-
-
-		d._windowUnloaders = [];
-		
-		d.windowUnloaded = function(){
-			// summary:
-			//		signal fired by impending window destruction. You may use
-			//		dojo.addOnWindowUnload() to register a listener for this
-			//		event. NOTE: if you wish to dojo.connect() to this method
-			//		to perform page/application cleanup, be aware that this
-			//		event WILL NOT fire if no handler has been registered with
-			//		dojo.addOnWindowUnload. This behavior started in Dojo 1.3.
-			//		Previous versions always triggered dojo.windowUnloaded. See
-			//		dojo.addOnWindowUnload for more info.
-			var mll = d._windowUnloaders;
-			while(mll.length){
-				(mll.pop())();
-			}
-			d = null;
-		};
-
-		var _onWindowUnloadAttached = 0;
-		d.addOnWindowUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){
-			// summary:
-			//		registers a function to be triggered when window.onunload
-			//		fires.
-			//	description:
-			//		The first time that addOnWindowUnload is called Dojo
-			//		will register a page listener to trigger your unload
-			//		handler with. Note that registering these handlers may
-			//		destory "fastback" page caching in browsers that support
-			//		it. Be careful trying to modify the DOM or access
-			//		JavaScript properties during this phase of page unloading:
-			//		they may not always be available. Consider
-			//		dojo.addOnUnload() if you need to modify the DOM or do
-			//		heavy JavaScript work since it fires at the eqivalent of
-			//		the page's "onbeforeunload" event.
-			// example:
-			//	|	dojo.addOnWindowUnload(functionPointer)
-			//	|	dojo.addOnWindowUnload(object, "functionName");
-			//	|	dojo.addOnWindowUnload(object, function(){ /* ... */});
-
-			d._onto(d._windowUnloaders, obj, functionName);
-			if(!_onWindowUnloadAttached){
-				_onWindowUnloadAttached = 1;
-				_handleNodeEvent("onunload", d.windowUnloaded);
-			}
-		};
-
-		var _onUnloadAttached = 0;
-		d.addOnUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){
-			// summary:
-			//		registers a function to be triggered when the page unloads.
-			//	description:
-			//		The first time that addOnUnload is called Dojo will
-			//		register a page listener to trigger your unload handler
-			//		with.
-			//
-			//		In a browser enviroment, the functions will be triggered
-			//		during the window.onbeforeunload event. Be careful of doing
-			//		too much work in an unload handler. onbeforeunload can be
-			//		triggered if a link to download a file is clicked, or if
-			//		the link is a javascript: link. In these cases, the
-			//		onbeforeunload event fires, but the document is not
-			//		actually destroyed. So be careful about doing destructive
-			//		operations in a dojo.addOnUnload callback.
-			//
-			//		Further note that calling dojo.addOnUnload will prevent
-			//		browsers from using a "fast back" cache to make page
-			//		loading via back button instantaneous.
-			// example:
-			//	|	dojo.addOnUnload(functionPointer)
-			//	|	dojo.addOnUnload(object, "functionName")
-			//	|	dojo.addOnUnload(object, function(){ /* ... */});
-
-			d._onto(d._unloaders, obj, functionName);
-			if(!_onUnloadAttached){
-				_onUnloadAttached = 1;
-				_handleNodeEvent("onbeforeunload", dojo.unloaded);
-			}
-		};
-
-	})();
-
-	//START DOMContentLoaded
-	dojo._initFired = false;
-	dojo._loadInit = function(e){
-		if(dojo._scrollIntervalId){
-			clearInterval(dojo._scrollIntervalId);
-			dojo._scrollIntervalId = 0;
-		}
-
-		if(!dojo._initFired){
-			dojo._initFired = true;
-
-			//Help out IE to avoid memory leak.
-			if(!dojo.config.afterOnLoad && window.detachEvent){
-				window.detachEvent("onload", dojo._loadInit);
-			}
-
-			if(dojo._inFlightCount == 0){
-				dojo._modulesLoaded();
-			}
-		}
-	}
-
-	if(!dojo.config.afterOnLoad){
-		if(document.addEventListener){
-			//Standards. Hooray! Assumption here that if standards based,
-			//it knows about DOMContentLoaded. It is OK if it does not, the fall through
-			//to window onload should be good enough.
-			document.addEventListener("DOMContentLoaded", dojo._loadInit, false);
-			window.addEventListener("load", dojo._loadInit, false);
-		}else if(window.attachEvent){
-			window.attachEvent("onload", dojo._loadInit);
-
-			//DOMContentLoaded approximation. Diego Perini found this MSDN article
-			//that indicates doScroll is available after DOM ready, so do a setTimeout
-			//to check when it is available.
-			//http://msdn.microsoft.com/en-us/library/ms531426.aspx
-			if(!dojo.config.skipIeDomLoaded && self === self.top){
-				dojo._scrollIntervalId = setInterval(function (){
-					try{
-						//When dojo is loaded into an iframe in an IE HTML Application
-						//(HTA), such as in a selenium test, javascript in the iframe
-						//can't see anything outside of it, so self===self.top is true,
-						//but the iframe is not the top window and doScroll will be
-						//available before document.body is set. Test document.body
-						//before trying the doScroll trick
-						if(document.body){
-							document.documentElement.doScroll("left");
-							dojo._loadInit();
-						}
-					}catch (e){}
-				}, 30);
-			}
-		}
-	}
-
-		if(dojo.isIE){
-		try{
-			(function(){
-				document.namespaces.add("v", "urn:schemas-microsoft-com:vml");
-				var vmlElems = ["*", "group", "roundrect", "oval", "shape", "rect", "imagedata", "path", "textpath", "text"],
-					i = 0, l = 1, s = document.createStyleSheet();
-				if(dojo.isIE >= 8){
-					i = 1;
-					l = vmlElems.length;
-				}
-				for(; i < l; ++i){
-					s.addRule("v\\:" + vmlElems[i], "behavior:url(#default#VML); display:inline-block");
-				}
-			})();
-		}catch(e){}
-	}
-		//END DOMContentLoaded
-
-
-	/*
-	OpenAjax.subscribe("OpenAjax", "onload", function(){
-		if(dojo._inFlightCount == 0){
-			dojo._modulesLoaded();
-		}
-	});
-
-	OpenAjax.subscribe("OpenAjax", "onunload", function(){
-		dojo.unloaded();
-	});
-	*/
-} //if (typeof window != 'undefined')
-
-//Register any module paths set up in djConfig. Need to do this
-//in the hostenvs since hostenv_browser can read djConfig from a
-//script tag's attribute.
-(function(){
-	var mp = dojo.config["modulePaths"];
-	if(mp){
-		for(var param in mp){
-			dojo.registerModulePath(param, mp[param]);
-		}
-	}
-})();
-
-//Load debug code if necessary.
-if(dojo.config.isDebug){
-	dojo.require("dojo._firebug.firebug");
-}
-
-if(dojo.config.debugAtAllCosts){
-	// this breaks the new AMD based module loader. The XDomain won't be necessary
-	// anyway if you switch to the asynchronous loader
-	//dojo.config.useXDomain = true;
-	//dojo.require("dojo._base._loader.loader_xd");
-	dojo.require("dojo._base._loader.loader_debug");
-	dojo.require("dojo.i18n");
-}
-
diff --git a/lib/dojo/_base/_loader/hostenv_rhino.js b/lib/dojo/_base/_loader/hostenv_rhino.js
deleted file mode 100644
index e3aa78524..000000000
--- a/lib/dojo/_base/_loader/hostenv_rhino.js
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
-	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
-*/
-
-
-/*
-* Rhino host environment
-*/
-
-if(dojo.config["baseUrl"]){
-	dojo.baseUrl = dojo.config["baseUrl"];
-}else{
-	dojo.baseUrl = "./";
-}
-
-dojo.locale = dojo.locale || String(java.util.Locale.getDefault().toString().replace('_','-').toLowerCase());
-dojo._name = 'rhino';
-dojo.isRhino = true;
-
-if(typeof print == "function"){
-	console.debug = print;
-}
-
-if(!("byId" in dojo)){
-	dojo.byId = function(id, doc){
-		if(id && (typeof id == "string" || id instanceof String)){
-			if(!doc){ doc = document; }
-			return doc.getElementById(id);
-		}
-		return id; // assume it's a node
-	}
-}
-
-dojo._isLocalUrl = function(/*String*/ uri) {
-	// summary:
-	// 		determines if URI is local or not.
-
-	var local = (new java.io.File(uri)).exists();
-	if(!local){
-		var stream;
-		//Try remote URL. Allow this method to throw,
-		//but still do cleanup.
-		try{
-			// try it as a file first, URL second
-			stream = (new java.net.URL(uri)).openStream();
-			// close the stream so we don't leak resources
-			stream.close();
-		}finally{
-			if(stream && stream.close){
-				stream.close();
-			}
-		}
-	}
-	return local;
-}
-
-// see comments in spidermonkey loadUri
-dojo._loadUri = function(uri, cb){
-	if(dojo._loadedUrls[uri]){
-		return true; // Boolean
-	}
-	try{
-		var local;
-		try{
-			local = dojo._isLocalUrl(uri);
-		}catch(e){
-			// no debug output; this failure just means the uri was not found.
-			return false;
-		}
-
-		dojo._loadedUrls[uri] = true;
-		//FIXME: Use Rhino 1.6 native readFile/readUrl if available?
-		if(cb){
-			var contents = (local ? readText : readUri)(uri, "UTF-8");
-
-			// patch up the input to eval until https://bugzilla.mozilla.org/show_bug.cgi?id=471005 is fixed.
-			if(!eval("'\u200f'").length){
-				contents = String(contents).replace(/[\u200E\u200F\u202A-\u202E]/g, function(match){
-					return "\\u" + match.charCodeAt(0).toString(16);
-				})
-			}
-			contents = /^define\(/.test(contents) ? contents : '('+contents+')';
-			cb(eval(contents));
-		}else{
-			load(uri);
-		}
-		dojo._loadedUrls.push(uri);
-		return true;
-	}catch(e){
-		dojo._loadedUrls[uri] = false;
-		console.debug("rhino load('" + uri + "') failed. Exception: " + e);
-		return false;
-	}
-}
-
-dojo.exit = function(exitcode){
-	quit(exitcode);
-}
-
-// reading a file from disk in Java is a humiliating experience by any measure.
-// Lets avoid that and just get the freaking text
-function readText(path, encoding){
-	encoding = encoding || "utf-8";
-	// NOTE: we intentionally avoid handling exceptions, since the caller will
-	// want to know
-	var jf = new java.io.File(path);
-	var is = new java.io.FileInputStream(jf);
-	return dj_readInputStream(is, encoding);
-}
-
-function readUri(uri, encoding){
-	var conn = (new java.net.URL(uri)).openConnection();
-	encoding = encoding || conn.getContentEncoding() || "utf-8";
-	var is = conn.getInputStream();
-	return dj_readInputStream(is, encoding);
-}
-
-function dj_readInputStream(is, encoding){
-	var input = new java.io.BufferedReader(new java.io.InputStreamReader(is, encoding));
-	try {
-		var sb = new java.lang.StringBuffer();
-		var line = "";
-		while((line = input.readLine()) !== null){
-			sb.append(line);
-			sb.append(java.lang.System.getProperty("line.separator"));
-		}
-		return sb.toString();
-	} finally {
-		input.close();
-	}
-}
-
-dojo._getText = function(/*URI*/ uri, /*Boolean*/ fail_ok){
-	// summary: Read the contents of the specified uri and return those contents.
-	// uri:
-	//		A relative or absolute uri.
-	// fail_ok:
-	//		Default false. If fail_ok and loading fails, return null
-	//		instead of throwing.
-	// returns: The response text. null is returned when there is a
-	//		failure and failure is okay (an exception otherwise)
-	try{
-		var local = dojo._isLocalUrl(uri);
-		var text = (local ? readText : readUri)(uri, "UTF-8");
-		if(text !== null){
-			//Force JavaScript string.
-			text += "";
-		}
-		return text;
-	}catch(e){
-		if(fail_ok){
-			return null;
-		}else{
-			throw e;
-		}
-	}
-}
-
-// summary:
-//		return the document object associated with the dojo.global
-dojo.doc = typeof document != "undefined" ? document : null;
-
-dojo.body = function(){
-	return document.body;
-}
-
-// Supply setTimeout/clearTimeout implementations if they aren't already there
-// Note: this assumes that we define both if one is not provided... there might
-// be a better way to do this if there is a use case where one is defined but
-// not the other
-if(typeof setTimeout == "undefined" || typeof clearTimeout == "undefined"){
-	dojo._timeouts = [];
-	clearTimeout = function(idx){
-		if(!dojo._timeouts[idx]){ return; }
-		dojo._timeouts[idx].stop();
-	}
-
-	setTimeout = function(func, delay){
-		// summary: provides timed callbacks using Java threads
-
-		var def={
-			sleepTime:delay,
-			hasSlept:false,
-		
-			run:function(){
-				if(!this.hasSlept){
-					this.hasSlept=true;
-					java.lang.Thread.currentThread().sleep(this.sleepTime);
-				}
-				try{
-					func();
-				}catch(e){
-					console.debug("Error running setTimeout thread:" + e);
-				}
-			}
-		};
-	
-		var runnable = new java.lang.Runnable(def);
-		var thread = new java.lang.Thread(runnable);
-		thread.start();
-		return dojo._timeouts.push(thread)-1;
-	}
-}
-
-//Register any module paths set up in djConfig. Need to do this
-//in the hostenvs since hostenv_browser can read djConfig from a
-//script tag's attribute.
-if(dojo.config["modulePaths"]){
-	for(var param in dojo.config["modulePaths"]){
-		dojo.registerModulePath(param, dojo.config["modulePaths"][param]);
-	}
-}
diff --git a/lib/dojo/_base/_loader/loader.js b/lib/dojo/_base/_loader/loader.js
deleted file mode 100644
index 73df544fa..000000000
--- a/lib/dojo/_base/_loader/loader.js
+++ /dev/null
@@ -1,816 +0,0 @@
-/*
-	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.foo"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo.foo"] = true;
-/*
- * loader.js - A bootstrap module.  Runs before the hostenv_*.js file. Contains
- * all of the package loading methods.
- */
-(function(){
-	var d = dojo, currentModule;
-
-	d.mixin(d, {
-		_loadedModules: {},
-		_inFlightCount: 0,
-		_hasResource: {},
-
-		_modulePrefixes: {
-			dojo: 	{	name: "dojo", value: "." },
-			// dojox: 	{	name: "dojox", value: "../dojox" },
-			// dijit: 	{	name: "dijit", value: "../dijit" },
-			doh: 	{	name: "doh", value: "../util/doh" },
-			tests: 	{	name: "tests", value: "tests" }
-		},
-
-		_moduleHasPrefix: function(/*String*/module){
-			// summary: checks to see if module has been established
-			var mp = d._modulePrefixes;
-			return !!(mp[module] && mp[module].value); // Boolean
-		},
-
-		_getModulePrefix: function(/*String*/module){
-			// summary: gets the prefix associated with module
-			var mp = d._modulePrefixes;
-			if(d._moduleHasPrefix(module)){
-				return mp[module].value; // String
-			}
-			return module; // String
-		},
-
-		_loadedUrls: [],
-
-		//WARNING:
-		//		This variable is referenced by packages outside of bootstrap:
-		//		FloatingPane.js and undo/browser.js
-		_postLoad: false,
-
-		//Egad! Lots of test files push on this directly instead of using dojo.addOnLoad.
-		_loaders: [],
-		_unloaders: [],
-		_loadNotifying: false
-	});
-
-
-		dojo._loadPath = function(/*String*/relpath, /*String?*/module, /*Function?*/cb){
-		// 	summary:
-		//		Load a Javascript module given a relative path
-		//
-		//	description:
-		//		Loads and interprets the script located at relpath, which is
-		//		relative to the script root directory.  If the script is found but
-		//		its interpretation causes a runtime exception, that exception is
-		//		not caught by us, so the caller will see it.  We return a true
-		//		value if and only if the script is found.
-		//
-		// relpath:
-		//		A relative path to a script (no leading '/', and typically ending
-		//		in '.js').
-		// module:
-		//		A module whose existance to check for after loading a path.  Can be
-		//		used to determine success or failure of the load.
-		// cb:
-		//		a callback function to pass the result of evaluating the script
-
-		var uri = ((relpath.charAt(0) == '/' || relpath.match(/^\w+:/)) ? "" : d.baseUrl) + relpath;
-		try{
-			currentModule = module;
-			return !module ? d._loadUri(uri, cb) : d._loadUriAndCheck(uri, module, cb); // Boolean
-		}catch(e){
-			console.error(e);
-			return false; // Boolean
-		}finally{
-			currentModule = null;
-		}
-	}
-
-	dojo._loadUri = function(/*String*/uri, /*Function?*/cb){
-		//	summary:
-		//		Loads JavaScript from a URI
-		//	description:
-		//		Reads the contents of the URI, and evaluates the contents.  This is
-		//		used to load modules as well as resource bundles. Returns true if
-		//		it succeeded. Returns false if the URI reading failed.  Throws if
-		//		the evaluation throws.
-		//	uri: a uri which points at the script to be loaded
-		//	cb:
-		//		a callback function to process the result of evaluating the script
-		//		as an expression, typically used by the resource bundle loader to
-		//		load JSON-style resources
-
-		if(d._loadedUrls[uri]){
-			return true; // Boolean
-		}
-		d._inFlightCount++; // block addOnLoad calls that arrive while we're busy downloading
-		var contents = d._getText(uri, true);
-		if(contents){ // not 404, et al
-			d._loadedUrls[uri] = true;
-			d._loadedUrls.push(uri);
-			if(cb){
-				//conditional to support script-inject i18n bundle format
-				contents = /^define\(/.test(contents) ? contents : '('+contents+')';
-			}else{
-				//Only do the scoping if no callback. If a callback is specified,
-				//it is most likely the i18n bundle stuff.
-				contents = d._scopePrefix + contents + d._scopeSuffix;
-			}
-			if(!d.isIE){ contents += "\r\n//@ sourceURL=" + uri; } // debugging assist for Firebug
-			var value = d["eval"](contents);
-			if(cb){ cb(value); }
-		}
-		// Check to see if we need to call _callLoaded() due to an addOnLoad() that arrived while we were busy downloading
-		if(--d._inFlightCount == 0 && d._postLoad && d._loaders.length){
-			// We shouldn't be allowed to get here but Firefox allows an event
-			// (mouse, keybd, async xhrGet) to interrupt a synchronous xhrGet.
-			// If the current script block contains multiple require() statements, then after each
-			// require() returns, inFlightCount == 0, but we want to hold the _callLoaded() until
-			// all require()s are done since the out-of-sequence addOnLoad() presumably needs them all.
-			// setTimeout allows the next require() to start (if needed), and then we check this again.
-			setTimeout(function(){
-				// If inFlightCount > 0, then multiple require()s are running sequentially and
-				// the next require() started after setTimeout() was executed but before we got here.
-				if(d._inFlightCount == 0){
-					d._callLoaded();
-				}
-			}, 0);
-		}
-		return !!contents; // Boolean: contents? true : false
-	}
-	
-	// FIXME: probably need to add logging to this method
-	dojo._loadUriAndCheck = function(/*String*/uri, /*String*/moduleName, /*Function?*/cb){
-		// summary: calls loadUri then findModule and returns true if both succeed
-		var ok = false;
-		try{
-			ok = d._loadUri(uri, cb);
-		}catch(e){
-			console.error("failed loading " + uri + " with error: " + e);
-		}
-		return !!(ok && d._loadedModules[moduleName]); // Boolean
-	}
-
-	dojo.loaded = function(){
-		// summary:
-		//		signal fired when initial environment and package loading is
-		//		complete. You should use dojo.addOnLoad() instead of doing a
-		//		direct dojo.connect() to this method in order to handle
-		//		initialization tasks that require the environment to be
-		//		initialized. In a browser host,	declarative widgets will
-		//		be constructed when this function finishes runing.
-		d._loadNotifying = true;
-		d._postLoad = true;
-		var mll = d._loaders;
-
-		//Clear listeners so new ones can be added
-		//For other xdomain package loads after the initial load.
-		d._loaders = [];
-
-		for(var x = 0; x < mll.length; x++){
-			mll[x]();
-		}
-
-		d._loadNotifying = false;
-		
-		//Make sure nothing else got added to the onload queue
-		//after this first run. If something did, and we are not waiting for any
-		//more inflight resources, run again.
-		if(d._postLoad && d._inFlightCount == 0 && mll.length){
-			d._callLoaded();
-		}
-	}
-
-	dojo.unloaded = function(){
-		// summary:
-		//		signal fired by impending environment destruction. You should use
-		//		dojo.addOnUnload() instead of doing a direct dojo.connect() to this
-		//		method to perform page/application cleanup methods. See
-		//		dojo.addOnUnload for more info.
-		var mll = d._unloaders;
-		while(mll.length){
-			(mll.pop())();
-		}
-	}
-
-	d._onto = function(arr, obj, fn){
-		if(!fn){
-			arr.push(obj);
-		}else if(fn){
-			var func = (typeof fn == "string") ? obj[fn] : fn;
-			arr.push(function(){ func.call(obj); });
-		}
-	}
-
-	dojo.ready = dojo.addOnLoad = function(/*Object*/obj, /*String|Function?*/functionName){
-		// summary:
-		//		Registers a function to be triggered after the DOM and dojo.require() calls
-		//		have finished loading.
-		//
-		// description:
-		//		Registers a function to be triggered after the DOM has finished
-		//		loading and `dojo.require` modules have loaded. Widgets declared in markup
-		//		have been instantiated if `djConfig.parseOnLoad` is true when this fires.
-		//
-		//		Images and CSS files may or may not have finished downloading when
-		//		the specified function is called.  (Note that widgets' CSS and HTML
-		//		code is guaranteed to be downloaded before said widgets are
-		//		instantiated, though including css resouces BEFORE any script elements
-		//		is highly recommended).
-		//
-		// example:
-		//	Register an anonymous function to run when everything is ready
-		//	|	dojo.addOnLoad(function(){ doStuff(); });
-		//
-		// example:
-		//	Register a function to run when everything is ready by pointer:
-		//	|	var init = function(){ doStuff(); }
-		//	|	dojo.addOnLoad(init);
-		//
-		// example:
-		//	Register a function to run scoped to `object`, either by name or anonymously:
-		//	|	dojo.addOnLoad(object, "functionName");
-		//	|	dojo.addOnLoad(object, function(){ doStuff(); });
-
-		d._onto(d._loaders, obj, functionName);
-
-		//Added for xdomain loading. dojo.addOnLoad is used to
-		//indicate callbacks after doing some dojo.require() statements.
-		//In the xdomain case, if all the requires are loaded (after initial
-		//page load), then immediately call any listeners.
-		if(d._postLoad && d._inFlightCount == 0 && !d._loadNotifying){
-			d._callLoaded();
-		}
-	}
-
-	//Support calling dojo.addOnLoad via djConfig.addOnLoad. Support all the
-	//call permutations of dojo.addOnLoad. Mainly useful when dojo is added
-	//to the page after the page has loaded.
-	var dca = d.config.addOnLoad;
-	if(dca){
-		d.addOnLoad[(dca instanceof Array ? "apply" : "call")](d, dca);
-	}
-
-	dojo._modulesLoaded = function(){
-		if(d._postLoad){ return; }
-		if(d._inFlightCount > 0){
-			console.warn("files still in flight!");
-			return;
-		}
-		d._callLoaded();
-	}
-
-	dojo._callLoaded = function(){
-
-		// The "object" check is for IE, and the other opera check fixes an
-		// issue in Opera where it could not find the body element in some
-		// widget test cases.  For 0.9, maybe route all browsers through the
-		// setTimeout (need protection still for non-browser environments
-		// though). This might also help the issue with FF 2.0 and freezing
-		// issues where we try to do sync xhr while background css images are
-		// being loaded (trac #2572)? Consider for 0.9.
-		if(typeof setTimeout == "object" || (d.config.useXDomain && d.isOpera)){
-			setTimeout(
-				d.isAIR ? function(){ d.loaded(); } : d._scopeName + ".loaded();",
-				0);
-		}else{
-			d.loaded();
-		}
-	}
-
-	dojo._getModuleSymbols = function(/*String*/modulename){
-		// summary:
-		//		Converts a module name in dotted JS notation to an array
-		//		representing the path in the source tree
-		var syms = modulename.split(".");
-		for(var i = syms.length; i>0; i--){
-			var parentModule = syms.slice(0, i).join(".");
-			if(i == 1 && !d._moduleHasPrefix(parentModule)){
-				// Support default module directory (sibling of dojo) for top-level modules
-				syms[0] = "../" + syms[0];
-			}else{
-				var parentModulePath = d._getModulePrefix(parentModule);
-				if(parentModulePath != parentModule){
-					syms.splice(0, i, parentModulePath);
-					break;
-				}
-			}
-		}
-		return syms; // Array
-	}
-
-	dojo._global_omit_module_check = false;
-
-	dojo.loadInit = function(/*Function*/init){
-		//	summary:
-		//		Executes a function that needs to be executed for the loader's dojo.requireIf
-		//		resolutions to work. This is needed mostly for the xdomain loader case where
-		//		a function needs to be executed to set up the possible values for a dojo.requireIf
-		//		call.
-		//	init:
-		//		a function reference. Executed immediately.
-		//	description: This function is mainly a marker for the xdomain loader to know parts of
-		//		code that needs be executed outside the function wrappper that is placed around modules.
-		//		The init function could be executed more than once, and it should make no assumptions
-		//		on what is loaded, or what modules are available. Only the functionality in Dojo Base
-		//		is allowed to be used. Avoid using this method. For a valid use case,
-		//		see the source for dojox.gfx.
-		init();
-	}
-
-	dojo._loadModule = dojo.require = function(/*String*/moduleName, /*Boolean?*/omitModuleCheck){
-		//	summary:
-		//		loads a Javascript module from the appropriate URI
-		//
-		//	moduleName: String
-		//		module name to load, using periods for separators,
-		//		 e.g. "dojo.date.locale".  Module paths are de-referenced by dojo's
-		//		internal mapping of locations to names and are disambiguated by
-		//		longest prefix. See `dojo.registerModulePath()` for details on
-		//		registering new modules.
-		//
-		//	omitModuleCheck: Boolean?
-		//		if `true`, omitModuleCheck skips the step of ensuring that the
-		//		loaded file actually defines the symbol it is referenced by.
-		//		For example if it called as `dojo.require("a.b.c")` and the
-		//		file located at `a/b/c.js` does not define an object `a.b.c`,
-		//		and exception will be throws whereas no exception is raised
-		//		when called as `dojo.require("a.b.c", true)`
-		//
-		//	description:
-		// 		Modules are loaded via dojo.require by using one of two loaders: the normal loader
-		// 		and the xdomain loader. The xdomain loader is used when dojo was built with a
-		// 		custom build that specified loader=xdomain and the module lives on a modulePath
-		// 		that is a whole URL, with protocol and a domain. The versions of Dojo that are on
-		// 		the Google and AOL CDNs use the xdomain loader.
-		//
-		// 		If the module is loaded via the xdomain loader, it is an asynchronous load, since
-		// 		the module is added via a dynamically created script tag. This
-		// 		means that dojo.require() can return before the module has loaded. However, this
-		// 		should only happen in the case where you do dojo.require calls in the top-level
-		// 		HTML page, or if you purposely avoid the loader checking for dojo.require
-		// 		dependencies in your module by using a syntax like dojo["require"] to load the module.
-		//
-		// 		Sometimes it is useful to not have the loader detect the dojo.require calls in the
-		// 		module so that you can dynamically load the modules as a result of an action on the
-		// 		page, instead of right at module load time.
-		//
-		// 		Also, for script blocks in an HTML page, the loader does not pre-process them, so
-		// 		it does not know to download the modules before the dojo.require calls occur.
-		//
-		// 		So, in those two cases, when you want on-the-fly module loading or for script blocks
-		// 		in the HTML page, special care must be taken if the dojo.required code is loaded
-		// 		asynchronously. To make sure you can execute code that depends on the dojo.required
-		// 		modules, be sure to add the code that depends on the modules in a dojo.addOnLoad()
-		// 		callback. dojo.addOnLoad waits for all outstanding modules to finish loading before
-		// 		executing.
-		//
-		// 		This type of syntax works with both xdomain and normal loaders, so it is good
-		// 		practice to always use this idiom for on-the-fly code loading and in HTML script
-		// 		blocks. If at some point you change loaders and where the code is loaded from,
-		// 		it will all still work.
-		//
-		// 		More on how dojo.require
-		//		`dojo.require("A.B")` first checks to see if symbol A.B is
-		//		defined. If it is, it is simply returned (nothing to do).
-		//
-		//		If it is not defined, it will look for `A/B.js` in the script root
-		//		directory.
-		//
-		//		`dojo.require` throws an exception if it cannot find a file
-		//		to load, or if the symbol `A.B` is not defined after loading.
-		//
-		//		It returns the object `A.B`, but note the caveats above about on-the-fly loading and
-		// 		HTML script blocks when the xdomain loader is loading a module.
-		//
-		//		`dojo.require()` does nothing about importing symbols into
-		//		the current namespace.  It is presumed that the caller will
-		//		take care of that.
-		//
-		// 	example:
-		// 		To use dojo.require in conjunction with dojo.ready:
-		//
-		//		|	dojo.require("foo");
-		//		|	dojo.require("bar");
-		//	   	|	dojo.addOnLoad(function(){
-		//	   	|		//you can now safely do something with foo and bar
-		//	   	|	});
-		//
-		//	example:
-		//		For example, to import all symbols into a local block, you might write:
-		//
-		//		|	with (dojo.require("A.B")) {
-		//		|		...
-		//		|	}
-		//
-		//		And to import just the leaf symbol to a local variable:
-		//
-		//		|	var B = dojo.require("A.B");
-		//	   	|	...
-		//
-		//	returns:
-		//		the required namespace object
-		omitModuleCheck = d._global_omit_module_check || omitModuleCheck;
-
-		//Check if it is already loaded.
-		var module = d._loadedModules[moduleName];
-		if(module){
-			return module;
-		}
-
-		// convert periods to slashes
-		var relpath = d._getModuleSymbols(moduleName).join("/") + '.js';
-		var modArg = !omitModuleCheck ? moduleName : null;
-		var ok = d._loadPath(relpath, modArg);
-		if(!ok && !omitModuleCheck){
-			throw new Error("Could not load '" + moduleName + "'; last tried '" + relpath + "'");
-		}
-
-		// check that the symbol was defined
-		// Don't bother if we're doing xdomain (asynchronous) loading.
-		if(!omitModuleCheck && !d._isXDomain){
-			// pass in false so we can give better error
-			module = d._loadedModules[moduleName];
-			if(!module){
-				throw new Error("symbol '" + moduleName + "' is not defined after loading '" + relpath + "'");
-			}
-		}
-
-		return module;
-	}
-
-	dojo.provide = function(/*String*/ resourceName){
-		//	summary:
-		//		Register a resource with the package system. Works in conjunction with `dojo.require`
-		//
-		//	description:
-		//		Each javascript source file is called a resource.  When a
-		//		resource is loaded by the browser, `dojo.provide()` registers
-		//		that it has been loaded.
-		//
-		//		Each javascript source file must have at least one
-		//		`dojo.provide()` call at the top of the file, corresponding to
-		//		the file name.  For example, `js/dojo/foo.js` must have
-		//		`dojo.provide("dojo.foo");` before any calls to
-		//		`dojo.require()` are made.
-		//
-		//		For backwards compatibility reasons, in addition to registering
-		//		the resource, `dojo.provide()` also ensures that the javascript
-		//		object for the module exists.  For example,
-		//		`dojo.provide("dojox.data.FlickrStore")`, in addition to
-		//		registering that `FlickrStore.js` is a resource for the
-		//		`dojox.data` module, will ensure that the `dojox.data`
-		//		javascript object exists, so that calls like
-		//		`dojo.data.foo = function(){ ... }` don't fail.
-		//
-		//		In the case of a build where multiple javascript source files
-		//		are combined into one bigger file (similar to a .lib or .jar
-		//		file), that file may contain multiple dojo.provide() calls, to
-		//		note that it includes multiple resources.
-		//
-		// resourceName: String
-		//		A dot-sperated string identifying a resource.
-		//
-		// example:
-		//	Safely create a `my` object, and make dojo.require("my.CustomModule") work
-		//	|	dojo.provide("my.CustomModule");
-
-		//Make sure we have a string.
-		resourceName = resourceName + "";
-		return (d._loadedModules[resourceName] = d.getObject(resourceName, true)); // Object
-	}
-
-	//Start of old bootstrap2:
-
-	dojo.platformRequire = function(/*Object*/modMap){
-		//	summary:
-		//		require one or more modules based on which host environment
-		//		Dojo is currently operating in
-		//	description:
-		//		This method takes a "map" of arrays which one can use to
-		//		optionally load dojo modules. The map is indexed by the
-		//		possible dojo.name_ values, with two additional values:
-		//		"default" and "common". The items in the "default" array will
-		//		be loaded if none of the other items have been choosen based on
-		//		dojo.name_, set by your host environment. The items in the
-		//		"common" array will *always* be loaded, regardless of which
-		//		list is chosen.
-		//	example:
-		//		|	dojo.platformRequire({
-		//		|		browser: [
-		//		|			"foo.sample", // simple module
-		//		|			"foo.test",
-		//		|			["foo.bar.baz", true] // skip object check in _loadModule (dojo.require)
-		//		|		],
-		//		|		default: [ "foo.sample._base" ],
-		//		|		common: [ "important.module.common" ]
-		//		|	});
-
-		var common = modMap.common || [];
-		var result = common.concat(modMap[d._name] || modMap["default"] || []);
-
-		for(var x=0; x<result.length; x++){
-			var curr = result[x];
-			if(curr.constructor == Array){
-				d._loadModule.apply(d, curr);
-			}else{
-				d._loadModule(curr);
-			}
-		}
-	}
-
-	dojo.requireIf = function(/*Boolean*/ condition, /*String*/ resourceName){
-		// summary:
-		//		If the condition is true then call `dojo.require()` for the specified
-		//		resource
-		//
-		// example:
-		//	|	dojo.requireIf(dojo.isBrowser, "my.special.Module");
-		
-		if(condition === true){
-			// FIXME: why do we support chained require()'s here? does the build system?
-			var args = [];
-			for(var i = 1; i < arguments.length; i++){
-				args.push(arguments[i]);
-			}
-			d.require.apply(d, args);
-		}
-	}
-
-	dojo.requireAfterIf = d.requireIf;
-
-	dojo.registerModulePath = function(/*String*/module, /*String*/prefix){
-		//	summary:
-		//		Maps a module name to a path
-		//	description:
-		//		An unregistered module is given the default path of ../[module],
-		//		relative to Dojo root. For example, module acme is mapped to
-		//		../acme.  If you want to use a different module name, use
-		//		dojo.registerModulePath.
-		//	example:
-		//		If your dojo.js is located at this location in the web root:
-		//	|	/myapp/js/dojo/dojo/dojo.js
-		//		and your modules are located at:
-		//	|	/myapp/js/foo/bar.js
-		//	|	/myapp/js/foo/baz.js
-		//	|	/myapp/js/foo/thud/xyzzy.js
-		//		Your application can tell Dojo to locate the "foo" namespace by calling:
-		//	|	dojo.registerModulePath("foo", "../../foo");
-		//		At which point you can then use dojo.require() to load the
-		//		modules (assuming they provide() the same things which are
-		//		required). The full code might be:
-		//	|	<script type="text/javascript"
-		//	|		src="/myapp/js/dojo/dojo/dojo.js"></script>
-		//	|	<script type="text/javascript">
-		//	|		dojo.registerModulePath("foo", "../../foo");
-		//	|		dojo.require("foo.bar");
-		//	|		dojo.require("foo.baz");
-		//	|		dojo.require("foo.thud.xyzzy");
-		//	|	</script>
-		d._modulePrefixes[module] = { name: module, value: prefix };
-	};
-	
-	dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String?*/availableFlatLocales){
-		// summary:
-		//		Declares translated resources and loads them if necessary, in the
-		//		same style as dojo.require.  Contents of the resource bundle are
-		//		typically strings, but may be any name/value pair, represented in
-		//		JSON format.  See also `dojo.i18n.getLocalization`.
-		//
-		// description:
-		//		Load translated resource bundles provided underneath the "nls"
-		//		directory within a package.  Translated resources may be located in
-		//		different packages throughout the source tree.
-		//
-		//		Each directory is named for a locale as specified by RFC 3066,
-		//		(http://www.ietf.org/rfc/rfc3066.txt), normalized in lowercase.
-		//		Note that the two bundles in the example do not define all the
-		//		same variants.  For a given locale, bundles will be loaded for
-		//		that locale and all more general locales above it, including a
-		//		fallback at the root directory.  For example, a declaration for
-		//		the "de-at" locale will first load `nls/de-at/bundleone.js`,
-		//		then `nls/de/bundleone.js` and finally `nls/bundleone.js`.  The
-		//		data will be flattened into a single Object so that lookups
-		//		will follow this cascading pattern.  An optional build step can
-		//		preload the bundles to avoid data redundancy and the multiple
-		//		network hits normally required to load these resources.
-		//
-		// moduleName:
-		//		name of the package containing the "nls" directory in which the
-		//		bundle is found
-		//
-		// bundleName:
-		//		bundle name, i.e. the filename without the '.js' suffix. Using "nls" as a
-		//		a bundle name is not supported, since "nls" is the name of the folder
-		//		that holds bundles. Using "nls" as the bundle name will cause problems
-		//		with the custom build.
-		//
-		// locale:
-		//		the locale to load (optional)  By default, the browser's user
-		//		locale as defined by dojo.locale
-		//
-		// availableFlatLocales:
-		//		A comma-separated list of the available, flattened locales for this
-		//		bundle. This argument should only be set by the build process.
-		//
-		//	example:
-		//		A particular widget may define one or more resource bundles,
-		//		structured in a program as follows, where moduleName is
-		//		mycode.mywidget and bundleNames available include bundleone and
-		//		bundletwo:
-		//	|		...
-		//	|	mycode/
-		//	|		mywidget/
-		//	|			nls/
-		//	|				bundleone.js (the fallback translation, English in this example)
-		//	|				bundletwo.js (also a fallback translation)
-		//	|				de/
-		//	|					bundleone.js
-		//	|					bundletwo.js
-		//	|				de-at/
-		//	|					bundleone.js
-		//	|				en/
-		//	|					(empty; use the fallback translation)
-		//	|				en-us/
-		//	|					bundleone.js
-		//	|				en-gb/
-		//	|					bundleone.js
-		//	|				es/
-		//	|					bundleone.js
-		//	|					bundletwo.js
-		//	|				  ...etc
-		//	|				...
-		//
-
-		d.require("dojo.i18n");
-		d.i18n._requireLocalization.apply(d.hostenv, arguments);
-	};
-
-
-	var ore = new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"),
-		ire = new RegExp("^((([^\\[:]+):)?([^@]+)@)?(\\[([^\\]]+)\\]|([^\\[:]*))(:([0-9]+))?$");
-
-	dojo._Url = function(/*dojo._Url|String...*/){
-		// summary:
-		//		Constructor to create an object representing a URL.
-		//		It is marked as private, since we might consider removing
-		//		or simplifying it.
-		// description:
-		//		Each argument is evaluated in order relative to the next until
-		//		a canonical uri is produced. To get an absolute Uri relative to
-		//		the current document use:
-		//      	new dojo._Url(document.baseURI, url)
-
-		var n = null,
-			_a = arguments,
-			uri = [_a[0]];
-		// resolve uri components relative to each other
-		for(var i = 1; i<_a.length; i++){
-			if(!_a[i]){ continue; }
-
-			// Safari doesn't support this.constructor so we have to be explicit
-			// FIXME: Tracked (and fixed) in Webkit bug 3537.
-			//		http://bugs.webkit.org/show_bug.cgi?id=3537
-			var relobj = new d._Url(_a[i]+""),
-				uriobj = new d._Url(uri[0]+"");
-
-			if(
-				relobj.path == "" &&
-				!relobj.scheme &&
-				!relobj.authority &&
-				!relobj.query
-			){
-				if(relobj.fragment != n){
-					uriobj.fragment = relobj.fragment;
-				}
-				relobj = uriobj;
-			}else if(!relobj.scheme){
-				relobj.scheme = uriobj.scheme;
-
-				if(!relobj.authority){
-					relobj.authority = uriobj.authority;
-
-					if(relobj.path.charAt(0) != "/"){
-						var path = uriobj.path.substring(0,
-							uriobj.path.lastIndexOf("/") + 1) + relobj.path;
-
-						var segs = path.split("/");
-						for(var j = 0; j < segs.length; j++){
-							if(segs[j] == "."){
-								// flatten "./" references
-								if(j == segs.length - 1){
-									segs[j] = "";
-								}else{
-									segs.splice(j, 1);
-									j--;
-								}
-							}else if(j > 0 && !(j == 1 && segs[0] == "") &&
-								segs[j] == ".." && segs[j-1] != ".."){
-								// flatten "../" references
-								if(j == (segs.length - 1)){
-									segs.splice(j, 1);
-									segs[j - 1] = "";
-								}else{
-									segs.splice(j - 1, 2);
-									j -= 2;
-								}
-							}
-						}
-						relobj.path = segs.join("/");
-					}
-				}
-			}
-
-			uri = [];
-			if(relobj.scheme){
-				uri.push(relobj.scheme, ":");
-			}
-			if(relobj.authority){
-				uri.push("//", relobj.authority);
-			}
-			uri.push(relobj.path);
-			if(relobj.query){
-				uri.push("?", relobj.query);
-			}
-			if(relobj.fragment){
-				uri.push("#", relobj.fragment);
-			}
-		}
-
-		this.uri = uri.join("");
-
-		// break the uri into its main components
-		var r = this.uri.match(ore);
-
-		this.scheme = r[2] || (r[1] ? "" : n);
-		this.authority = r[4] || (r[3] ? "" : n);
-		this.path = r[5]; // can never be undefined
-		this.query = r[7] || (r[6] ? "" : n);
-		this.fragment  = r[9] || (r[8] ? "" : n);
-
-		if(this.authority != n){
-			// server based naming authority
-			r = this.authority.match(ire);
-
-			this.user = r[3] || n;
-			this.password = r[4] || n;
-			this.host = r[6] || r[7]; // ipv6 || ipv4
-			this.port = r[9] || n;
-		}
-	}
-
-	dojo._Url.prototype.toString = function(){ return this.uri; };
-
-	dojo.moduleUrl = function(/*String*/module, /*dojo._Url||String*/url){
-		//	summary:
-		//		Returns a `dojo._Url` object 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");
-		// 	|	// NOTE: we assign the string representation of the url object
-		//	|	img.src = pngPath.toString();
-		//	|	// 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");
-
-		var loc = d._getModuleSymbols(module).join('/');
-		if(!loc){ return null; }
-		if(loc.lastIndexOf("/") != loc.length-1){
-			loc += "/";
-		}
-		
-		//If the path is an absolute path (starts with a / or is on another
-		//domain/xdomain) then don't add the baseUrl.
-		var colonIndex = loc.indexOf(":");
-		if(loc.charAt(0) != "/" && (colonIndex == -1 || colonIndex > loc.indexOf("/"))){
-			loc = d.baseUrl + loc;
-		}
-
-		return new d._Url(loc, url); // dojo._Url
-	};
-
-
-
-})();
-
-}
diff --git a/lib/dojo/_base/_loader/loader_debug.js b/lib/dojo/_base/_loader/loader_debug.js
deleted file mode 100644
index f2043e4de..000000000
--- a/lib/dojo/_base/_loader/loader_debug.js
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
-	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._base._loader.loader_debug"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base._loader.loader_debug"] = true;
-dojo.provide("dojo._base._loader.loader_debug");
-
-//Override dojo.provide, so we can trigger the next
-//script tag for the next local module. We can only add one
-//at a time because there are browsers that execute script tags
-//in the order that the code is received, and not in the DOM order.
-dojo.nonDebugProvide = dojo.provide;
-
-dojo.provide = function(resourceName){
-	var dbgQueue = dojo["_xdDebugQueue"];
-	if(dbgQueue && dbgQueue.length > 0 && resourceName == dbgQueue["currentResourceName"]){
-		//Set a timeout so the module can be executed into existence. Normally the
-		//dojo.provide call in a module is the first line. Don't want to risk attaching
-		//another script tag until the current one finishes executing.
-		if(dojo.isAIR){
-			window.setTimeout(function(){dojo._xdDebugFileLoaded(resourceName);}, 1);
-		}else{
-			window.setTimeout(dojo._scopeName + "._xdDebugFileLoaded('" + resourceName + "')", 1);
-		}
-	}
-
-	return dojo.nonDebugProvide.apply(dojo, arguments);
-}
-
-dojo._xdDebugFileLoaded = function(resourceName){
-
-	if(!dojo._xdDebugScopeChecked){
-		//If using a scoped dojo, we need to expose dojo as a real global
-		//for the debugAtAllCosts stuff to work.
-		if(dojo._scopeName != "dojo"){
-			window.dojo = window[dojo.config.scopeMap[0][1]];
-			window.dijit = window[dojo.config.scopeMap[1][1]];
-			window.dojox = window[dojo.config.scopeMap[2][1]];
-		}
-
-		dojo._xdDebugScopeChecked = true;
-	}
-	
-	var dbgQueue = dojo._xdDebugQueue;
-	
-	if(resourceName && resourceName == dbgQueue.currentResourceName){
-		dbgQueue.shift();
-	}
-
-	if(dbgQueue.length == 0){
-		//Check for more modules that need debug loading.
-		//dojo._xdWatchInFlight will add more things to the debug
-		//queue if they just recently loaded but it was not detected
-		//between the dojo._xdWatchInFlight intervals.
-		dojo._xdWatchInFlight();
-	}
-
-	if(dbgQueue.length == 0){
-		dbgQueue.currentResourceName = null;
-
-		//Make sure nothing else is in flight.
-		//If something is still in flight, then it still
-		//needs to be added to debug queue after it loads.
-		for(var param in dojo._xdInFlight){
-			if(dojo._xdInFlight[param] === true){
-				return;
-			}
-		}
-
-		dojo._xdNotifyLoaded();
-	}else{
-		if(resourceName == dbgQueue.currentResourceName){
-			dbgQueue.currentResourceName = dbgQueue[0].resourceName;
-			var element = document.createElement("script");
-			element.type = "text/javascript";
-			element.src = dbgQueue[0].resourcePath;
-			document.getElementsByTagName("head")[0].appendChild(element);
-		}
-	}
-}
-
-}
diff --git a/lib/dojo/_base/_loader/loader_xd.js b/lib/dojo/_base/_loader/loader_xd.js
deleted file mode 100644
index e59f814c0..000000000
--- a/lib/dojo/_base/_loader/loader_xd.js
+++ /dev/null
@@ -1,727 +0,0 @@
-/*
-	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._base._loader.loader_xd"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base._loader.loader_xd"] = true;
-//Cross-domain resource loader.
-dojo.provide("dojo._base._loader.loader_xd");
-
-dojo._xdReset = function(){
-	//summary: Internal xd loader function. Resets the xd state.
-
-	//This flag indicates where or not we have crossed into xdomain territory. Once any resource says
-	//it is cross domain, then the rest of the resources have to be treated as xdomain because we need
-	//to evaluate resources in order. If there is a xdomain resource followed by a xhr resource, we can't load
-	//the xhr resource until the one before it finishes loading. The text of the xhr resource will be converted
-	//to match the format for a xd resource and put in the xd load queue.
-	dojo._isXDomain = dojo.config.useXDomain || false;
-
-	dojo._xdClearInterval();
-	dojo._xdInFlight = {};
-	dojo._xdOrderedReqs = [];
-	dojo._xdDepMap = {};
-	dojo._xdContents = [];
-	dojo._xdDefList = [];
-}
-
-dojo._xdClearInterval = function(){
-	//summary: Internal xd loader function.
-	//Clears the interval timer used to check on the
-	//status of in-flight xd module resource requests.
-	if(dojo._xdTimer){
-		clearInterval(dojo._xdTimer);
-		dojo._xdTimer = 0;
-	}
-}
-
-
-//Call reset immediately to set the state.
-dojo._xdReset();
-
-dojo._xdCreateResource = function(/*String*/contents, /*String*/resourceName, /*String*/resourcePath){
-	//summary: Internal xd loader function. Creates an xd module source given an
-	//non-xd module contents.
-
-	//Remove comments. Not perfect, but good enough for dependency resolution.
-	var depContents = contents.replace(/(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg , "");
-
-	//Find dependencies.
-	var deps = [];
-    var depRegExp = /dojo.(require|requireIf|provide|requireAfterIf|platformRequire|requireLocalization)\s*\(([\w\W]*?)\)/mg;
-    var match;
-	while((match = depRegExp.exec(depContents)) != null){
-		if(match[1] == "requireLocalization"){
-			//Need to load the local bundles asap, since they are not
-			//part of the list of modules watched for loading.
-			eval(match[0]);
-		}else{
-			deps.push('"' + match[1] + '", ' + match[2]);
-		}
-	}
-
-	//Create resource object and the call to _xdResourceLoaded.
-	var output = [];
-	output.push(dojo._scopeName + "._xdResourceLoaded(function(" + dojo._scopePrefixArgs + "){\n");
-
-	//See if there are any dojo.loadInit calls
-	var loadInitCalls = dojo._xdExtractLoadInits(contents);
-	if(loadInitCalls){
-		//Adjust fileContents since extractLoadInits removed something.
-		contents = loadInitCalls[0];
-		
-		//Add any loadInit calls to the top of the xd file.
-		for(var i = 1; i < loadInitCalls.length; i++){
-			output.push(loadInitCalls[i] + ";\n");
-		}
-	}
-
-	output.push("return {");
-
-	//Add dependencies
-	if(deps.length > 0){
-		output.push("depends: [");
-		for(i = 0; i < deps.length; i++){
-			if(i > 0){
-				output.push(",\n");
-			}
-			output.push("[" + deps[i] + "]");
-		}
-		output.push("],");
-	}
-
-	//Add the contents of the file inside a function.
-	//Pass in scope arguments so we can support multiple versions of the
-	//same module on a page.
-	output.push("\ndefineResource: function(" + dojo._scopePrefixArgs + "){");
-
-	//Don't put in the contents in the debugAtAllCosts case
-	//since the contents may have syntax errors. Let those
-	//get pushed up when the script tags are added to the page
-	//in the debugAtAllCosts case.
-	if(!dojo.config["debugAtAllCosts"] || resourceName == "dojo._base._loader.loader_debug"){
-		output.push(contents);
-	}
-	//Add isLocal property so we know if we have to do something different
-	//in debugAtAllCosts situations.
-	output.push("\n}, resourceName: '" + resourceName + "', resourcePath: '" + resourcePath + "'};});");
-	
-	return output.join(""); //String
-}
-
-dojo._xdExtractLoadInits = function(/*String*/fileContents){
-	//Extracts
-	var regexp = /dojo.loadInit\s*\(/g;
-	regexp.lastIndex = 0;
-
-	var parenRe = /[\(\)]/g;
-	parenRe.lastIndex = 0;
-
-	var results = [];
-	var matches;
-	while((matches = regexp.exec(fileContents))){
-		//Find end of the call by finding the matching end paren
-		parenRe.lastIndex = regexp.lastIndex;
-		var matchCount = 1;
-		var parenMatch;
-		while((parenMatch = parenRe.exec(fileContents))){
-			if(parenMatch[0] == ")"){
-				matchCount -= 1;
-			}else{
-				matchCount += 1;
-			}
-			if(matchCount == 0){
-				break;
-			}
-		}
-		
-		if(matchCount != 0){
-			throw "unmatched paren around character " + parenRe.lastIndex + " in: " + fileContents;
-		}
-
-		//Put the master matching string in the results.
-		var startIndex = regexp.lastIndex - matches[0].length;
-		results.push(fileContents.substring(startIndex, parenRe.lastIndex));
-
-		//Remove the matching section.
-		var remLength = parenRe.lastIndex - startIndex;
-		fileContents = fileContents.substring(0, startIndex) + fileContents.substring(parenRe.lastIndex, fileContents.length);
-
-		//Move the master regexp past the last matching paren point.
-		regexp.lastIndex = parenRe.lastIndex - remLength;
-
-		regexp.lastIndex = parenRe.lastIndex;
-	}
-
-	if(results.length > 0){
-		results.unshift(fileContents);
-	}
-
-	return (results.length ? results : null);
-}
-
-dojo._xdIsXDomainPath = function(/*string*/relpath) {
-    //summary: Figure out whether the path is local or x-domain
-	//If there is a colon before the first / then, we have a URL with a protocol.
-    
-	var colonIndex = relpath.indexOf(":");
-	var slashIndex = relpath.indexOf("/");
-
-	if(colonIndex > 0 && colonIndex < slashIndex || relpath.indexOf("//") === 0){
-		return true;
-	}else{
-		//Is the base script URI-based URL a cross domain URL?
-		//If so, then the relpath will be evaluated relative to
-		//baseUrl, and therefore qualify as xdomain.
-		//Only treat it as xdomain if the page does not have a
-		//host (file:// url), if the baseUrl does not match the
-		//current window's domain, or if the baseUrl starts with //.
-		//If baseUrl starts with // then it probably means that xdomain
-		//is wanted since it is such a specific path request. This is not completely robust,
-		//but something more robust would require normalizing the protocol on baseUrl and on the location
-		//to see if they differ. However, that requires more code, and // as a start path is unusual.
-		var url = dojo.baseUrl;
-		colonIndex = url.indexOf(":");
-		slashIndex = url.indexOf("/");
-		if(url.indexOf("//") === 0 || (colonIndex > 0 && colonIndex < slashIndex && (!location.host || url.indexOf("http://" + location.host) != 0))){
-			return true;
-		}
-	}
-    return false;
-}
-
-dojo._loadPath = function(/*String*/relpath, /*String?*/module, /*Function?*/cb){
-	//summary: Internal xd loader function. Overrides loadPath() from loader.js.
-	//xd loading requires slightly different behavior from loadPath().
-
-	var currentIsXDomain = dojo._xdIsXDomainPath(relpath);
-    dojo._isXDomain |= currentIsXDomain;
-
-	var uri = ((relpath.charAt(0) == '/' || relpath.match(/^\w+:/)) ? "" : dojo.baseUrl) + relpath;
-
-	try{
-		return ((!module || dojo._isXDomain) ? dojo._loadUri(uri, cb, currentIsXDomain, module) : dojo._loadUriAndCheck(uri, module, cb)); //Boolean
-	}catch(e){
-		console.error(e);
-		return false; //Boolean
-	}
-}
-
-dojo._xdCharSet = "utf-8";
-
-dojo._loadUri = function(/*String*/uri, /*Function?*/cb, /*boolean*/currentIsXDomain, /*String?*/module){
-	//summary: Internal xd loader function. Overrides loadUri() from loader.js.
-	//		xd loading requires slightly different behavior from loadPath().
-	//description: Wanted to override getText(), but it is used by
-	//		the widget code in too many, synchronous ways right now.
-	if(dojo._loadedUrls[uri]){
-		return 1; //Boolean
-	}
-
-	//Add the module (resource) to the list of modules.
-	//Only do this work if we have a modlue name. Otherwise,
-	//it is a non-xd i18n bundle, which can load immediately and does not
-	//need to be tracked. Also, don't track dojo.i18n, since it is a prerequisite
-	//and will be loaded correctly if we load it right away: it has no dependencies.
-	if(dojo._isXDomain && module && module != "dojo.i18n"){
-		dojo._xdOrderedReqs.push(module);
-
-		//Add to waiting resources if it is an xdomain resource.
-		//Don't add non-xdomain i18n bundles, those get evaled immediately.
-		if(currentIsXDomain || uri.indexOf("/nls/") == -1){
-			dojo._xdInFlight[module] = true;
-
-			//Increment inFlightCount
-			//This will stop the modulesLoaded from firing all the way.
-			dojo._inFlightCount++;
-		}
-
-		//Start timer
-		if(!dojo._xdTimer){
-			if(dojo.isAIR){
-				dojo._xdTimer = setInterval(function(){dojo._xdWatchInFlight();}, 100);
-			}else{
-				dojo._xdTimer = setInterval(dojo._scopeName + "._xdWatchInFlight();", 100);
-			}
-		}
-		dojo._xdStartTime = (new Date()).getTime();
-	}
-
-	if (currentIsXDomain){
-		//Fix name to be a .xd.fileextension name.
-		var lastIndex = uri.lastIndexOf('.');
-		if(lastIndex <= 0){
-			lastIndex = uri.length - 1;
-		}
-
-		var xdUri = uri.substring(0, lastIndex) + ".xd";
-		if(lastIndex != uri.length - 1){
-			xdUri += uri.substring(lastIndex, uri.length);
-		}
-
-		if (dojo.isAIR){
-			xdUri = xdUri.replace("app:/", "/");
-		}
-
-		//Add to script src
-		var element = document.createElement("script");
-		element.type = "text/javascript";
-		if(dojo._xdCharSet){
-			element.charset = dojo._xdCharSet;
-		}
-		element.src = xdUri;
-		if(!dojo.headElement){
-			dojo._headElement = document.getElementsByTagName("head")[0];
-
-			//Head element may not exist, particularly in html
-			//html 4 or tag soup cases where the page does not
-			//have a head tag in it. Use html element, since that will exist.
-			//Seems to be an issue mostly with Opera 9 and to lesser extent Safari 2
-			if(!dojo._headElement){
-				dojo._headElement = document.getElementsByTagName("html")[0];
-			}
-		}
-		dojo._headElement.appendChild(element);
-	}else{
-		var contents = dojo._getText(uri, null, true);
-		if(contents == null){ return 0; /*boolean*/}
-		
-		//If this is not xdomain, or if loading a i18n resource bundle, then send it down
-		//the normal eval/callback path.
-		if(dojo._isXDomain
-			&& uri.indexOf("/nls/") == -1
-			&& module != "dojo.i18n"){
-			var res = dojo._xdCreateResource(contents, module, uri);
-			dojo.eval(res);
-		}else{
-			if(cb){
-				contents = '('+contents+')';
-			}else{
-				//Only do the scoping if no callback. If a callback is specified,
-				//it is most likely the i18n bundle stuff.
-				contents = dojo._scopePrefix + contents + dojo._scopeSuffix;
-			}
-			var value = dojo["eval"](contents+"\r\n//@ sourceURL="+uri);
-			if(cb){
-				cb(value);
-			}
-		}
-	}
-
-	//These steps are done in the non-xd loader version of this function.
-	//Maintain these steps to fit in with the existing system.
-	dojo._loadedUrls[uri] = true;
-	dojo._loadedUrls.push(uri);
-	return true; //Boolean
-}
-
-dojo._xdResourceLoaded = function(/*Object*/res){
-	//summary: Internal xd loader function. Called by an xd module resource when
-	//it has been loaded via a script tag.
-	
-	//Evaluate the function with scopeArgs for multiversion support.
-	res = res.apply(dojo.global, dojo._scopeArgs);
-
-	//Work through dependencies.
-	var deps = res.depends;
-	var requireList = null;
-	var requireAfterList = null;
-	var provideList = [];
-	if(deps && deps.length > 0){
-		var dep = null;
-		var insertHint = 0;
-		var attachedResource = false;
-		for(var i = 0; i < deps.length; i++){
-			dep = deps[i];
-
-			//Look for specific dependency indicators.
-			if (dep[0] == "provide"){
-				provideList.push(dep[1]);
-			}else{
-				if(!requireList){
-					requireList = [];
-				}
-				if(!requireAfterList){
-					requireAfterList = [];
-				}
-
-				var unpackedDeps = dojo._xdUnpackDependency(dep);
-				if(unpackedDeps.requires){
-					requireList = requireList.concat(unpackedDeps.requires);
-				}
-				if(unpackedDeps.requiresAfter){
-					requireAfterList = requireAfterList.concat(unpackedDeps.requiresAfter);
-				}
-			}
-
-			//Call the dependency indicator to allow for the normal dojo setup.
-			//Only allow for one dot reference, for the i18n._preloadLocalizations calls
-			//(and maybe future, one-dot things).
-			var depType = dep[0];
-			var objPath = depType.split(".");
-			if(objPath.length == 2){
-				dojo[objPath[0]][objPath[1]].apply(dojo[objPath[0]], dep.slice(1));
-			}else{
-				dojo[depType].apply(dojo, dep.slice(1));
-			}
-		}
-
-
-		//If loading the debugAtAllCosts module, eval it right away since we need
-		//its functions to properly load the other modules.
-		if(provideList.length == 1 && provideList[0] == "dojo._base._loader.loader_debug"){
-			res.defineResource(dojo);
-		}else{
-			//Save off the resource contents for definition later.
-			var contentIndex = dojo._xdContents.push({
-					content: res.defineResource,
-					resourceName: res["resourceName"],
-					resourcePath: res["resourcePath"],
-					isDefined: false
-				}) - 1;
-	
-			//Add provide/requires to dependency map.
-			for(i = 0; i < provideList.length; i++){
-				dojo._xdDepMap[provideList[i]] = { requires: requireList, requiresAfter: requireAfterList, contentIndex: contentIndex };
-			}
-		}
-
-		//Now update the inflight status for any provided resources in this loaded resource.
-		//Do this at the very end (in a *separate* for loop) to avoid shutting down the
-		//inflight timer check too soon.
-		for(i = 0; i < provideList.length; i++){
-			dojo._xdInFlight[provideList[i]] = false;
-		}
-	}
-}
-
-dojo._xdLoadFlattenedBundle = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*Object*/bundleData){
-	//summary: Internal xd loader function. Used when loading
-	//a flattened localized bundle via a script tag.
-	locale = locale || "root";
-	var jsLoc = dojo.i18n.normalizeLocale(locale).replace('-', '_');
- 	var bundleResource = [moduleName, "nls", bundleName].join(".");
-	var bundle = dojo["provide"](bundleResource);
-	bundle[jsLoc] = bundleData;
-	
-	//Assign the bundle for the original locale(s) we wanted.
-	var mapName = [moduleName, jsLoc, bundleName].join(".");
-	var bundleMap = dojo._xdBundleMap[mapName];
-	if(bundleMap){
-		for(var param in bundleMap){
-			bundle[param] = bundleData;
-		}
-	}
-};
-
-
-dojo._xdInitExtraLocales = function(){
-	// Simulate the extra locale work that dojo.requireLocalization does.
-
-	var extra = dojo.config.extraLocale;
-	if(extra){
-		if(!extra instanceof Array){
-			extra = [extra];
-		}
-
-		dojo._xdReqLoc = dojo.xdRequireLocalization;
-		dojo.xdRequireLocalization = function(m, b, locale, fLocales){
-			dojo._xdReqLoc(m,b,locale, fLocales);
-			if(locale){return;}
-			for(var i=0; i<extra.length; i++){
-				dojo._xdReqLoc(m,b,extra[i], fLocales);
-			}
-		};
-	}
-}
-
-dojo._xdBundleMap = {};
-
-dojo.xdRequireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String*/availableFlatLocales){
-	//summary: Internal xd loader function. The xd version of dojo.requireLocalization.
-	
-
-	//Account for allowing multiple extra locales. Do this here inside the function
-	//since dojo._xdInitExtraLocales() depends on djConfig being set up, but that only
-	//happens after hostenv_browser runs. loader_xd has to come before hostenv_browser
-	//though since hostenv_browser can do a dojo.require for the debug module.
-	if(dojo._xdInitExtraLocales){
-		dojo._xdInitExtraLocales();
-		dojo._xdInitExtraLocales = null;
-		dojo.xdRequireLocalization.apply(dojo, arguments);
-		return;
-	}
-
-	var locales = availableFlatLocales.split(",");
-	
-	//Find the best-match locale to load.
-	//Assumes dojo.i18n has already been loaded. This is true for xdomain builds,
-	//since it is included in dojo.xd.js.
-	var jsLoc = dojo.i18n.normalizeLocale(locale);
-
-	var bestLocale = "";
-	for(var i = 0; i < locales.length; i++){
-		//Locale must match from start of string.
-		if(jsLoc.indexOf(locales[i]) == 0){
-			if(locales[i].length > bestLocale.length){
-				bestLocale = locales[i];
-			}
-		}
-	}
-
-	var fixedBestLocale = bestLocale.replace('-', '_');
-	//See if the bundle we are going to use is already loaded.
- 	var bundleResource = dojo.getObject([moduleName, "nls", bundleName].join("."));
-	if(!bundleResource || !bundleResource[fixedBestLocale]){
-		//Need to remember what locale we wanted and which one we actually use.
-		//Then when we load the one we are actually using, use that bundle for the one
-		//we originally wanted.
-		var mapName = [moduleName, (fixedBestLocale||"root"), bundleName].join(".");
-		var bundleMap = dojo._xdBundleMap[mapName];
-		if(!bundleMap){
-			bundleMap = dojo._xdBundleMap[mapName] = {};
-		}
-		bundleMap[jsLoc.replace('-', '_')] = true;
-		
-		//Do just a normal dojo.require so the resource tracking stuff works as usual.
-		dojo.require(moduleName + ".nls" + (bestLocale ? "." + bestLocale : "") + "." + bundleName);
-	}
-}
-
-// Replace dojo.requireLocalization with a wrapper
-dojo._xdRealRequireLocalization = dojo.requireLocalization;
-dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String*/availableFlatLocales){
-    // summary: loads a bundle intelligently based on whether the module is
-    // local or xd. Overrides the local-case implementation.
-    
-    var modulePath = dojo.moduleUrl(moduleName).toString();
-    if (dojo._xdIsXDomainPath(modulePath)) {
-        // call cross-domain loader
-        return dojo.xdRequireLocalization.apply(dojo, arguments);
-    } else {
-        // call local-loader
-        return dojo._xdRealRequireLocalization.apply(dojo, arguments);
-    }
-}
-
-//This is a bit brittle: it has to know about the dojo methods that deal with dependencies
-//It would be ideal to intercept the actual methods and do something fancy at that point,
-//but I have concern about knowing which provide to match to the dependency in that case,
-//since scripts can load whenever they want, and trigger new calls to dojo._xdResourceLoaded().
-dojo._xdUnpackDependency = function(/*Array*/dep){
-	//summary: Internal xd loader function. Determines what to do with a dependency
-	//that was listed in an xd version of a module contents.
-
-	//Extract the dependency(ies).
-	var newDeps = null;
-	var newAfterDeps = null;
-	switch(dep[0]){
-		case "requireIf":
-		case "requireAfterIf":
-			//First arg (dep[1]) is the test. Depedency is dep[2].
-			if(dep[1] === true){
-				newDeps = [{name: dep[2], content: null}];
-			}
-			break;
-		case "platformRequire":
-			var modMap = dep[1];
-			var common = modMap["common"]||[];
-			newDeps = (modMap[dojo.hostenv.name_]) ? common.concat(modMap[dojo.hostenv.name_]||[]) : common.concat(modMap["default"]||[]);
-			//Flatten the array of arrays into a one-level deep array.
-			//Each result could be an array of 3 elements  (the 3 arguments to dojo.require).
-			//We only need the first one.
-			if(newDeps){
-				for(var i = 0; i < newDeps.length; i++){
-					if(newDeps[i] instanceof Array){
-						newDeps[i] = {name: newDeps[i][0], content: null};
-					}else{
-						newDeps[i] = {name: newDeps[i], content: null};
-					}
-				}
-			}
-			break;
-		case "require":
-			//Just worry about dep[1]
-			newDeps = [{name: dep[1], content: null}];
-			break;
-		case "i18n._preloadLocalizations":
-			//We can eval these immediately, since they load i18n bundles.
-			//Since i18n bundles have no dependencies, whenever they are loaded
-			//in a script tag, they are evaluated immediately, so we do not have to
-			//treat them has an explicit dependency for the dependency mapping.
-			//We can call it immediately since dojo.i18n is part of dojo.xd.js.
-			dojo.i18n._preloadLocalizations.apply(dojo.i18n._preloadLocalizations, dep.slice(1));
-			break;
-	}
-
-	//The requireIf and requireAfterIf needs to be evaluated after the current resource is evaluated.
-	if(dep[0] == "requireAfterIf" || dep[0] == "requireIf"){
-		newAfterDeps = newDeps;
-		newDeps = null;
-	}
-	return {requires: newDeps, requiresAfter: newAfterDeps}; //Object
-}
-
-dojo._xdWalkReqs = function(){
-	//summary: Internal xd loader function.
-	//Walks the requires and evaluates module resource contents in
-	//the right order.
-	var reqChain = null;
-	var req;
-	for(var i = 0; i < dojo._xdOrderedReqs.length; i++){
-		req = dojo._xdOrderedReqs[i];
-		if(dojo._xdDepMap[req]){
-			reqChain = [req];
-			reqChain[req] = true; //Allow for fast lookup of the req in the array
-			dojo._xdEvalReqs(reqChain);
-		}
-	}
-}
-
-dojo._xdEvalReqs = function(/*Array*/reqChain){
-	//summary: Internal xd loader function.
-	//Does a depth first, breadth second search and eval of required modules.
-	while(reqChain.length > 0){
-		var req = reqChain[reqChain.length - 1];
-		var res = dojo._xdDepMap[req];
-		var i, reqs, nextReq;
-		if(res){
-			//Trace down any requires for this resource.
-			//START dojo._xdTraceReqs() inlining for small Safari 2.0 call stack
-			reqs = res.requires;
-			if(reqs && reqs.length > 0){
-				for(i = 0; i < reqs.length; i++){
-					nextReq = reqs[i].name;
-					if(nextReq && !reqChain[nextReq]){
-						//New req depedency. Follow it down.
-						reqChain.push(nextReq);
-						reqChain[nextReq] = true;
-						dojo._xdEvalReqs(reqChain);
-					}
-				}
-			}
-			//END dojo._xdTraceReqs() inlining for small Safari 2.0 call stack
-
-			//Evaluate the resource.
-			var contents = dojo._xdContents[res.contentIndex];
-			if(!contents.isDefined){
-				var content = contents.content;
-				content["resourceName"] = contents["resourceName"];
-				content["resourcePath"] = contents["resourcePath"];
-				dojo._xdDefList.push(content);
-				contents.isDefined = true;
-			}
-			dojo._xdDepMap[req] = null;
-
-			//Trace down any requireAfters for this resource.
-			//START dojo._xdTraceReqs() inlining for small Safari 2.0 call stack
-			reqs = res.requiresAfter;
-			if(reqs && reqs.length > 0){
-				for(i = 0; i < reqs.length; i++){
-					nextReq = reqs[i].name;
-					if(nextReq && !reqChain[nextReq]){
-						//New req depedency. Follow it down.
-						reqChain.push(nextReq);
-						reqChain[nextReq] = true;
-						dojo._xdEvalReqs(reqChain);
-					}
-				}
-			}
-			//END dojo._xdTraceReqs() inlining for small Safari 2.0 call stack
-		}
-
-		//Done with that require. Remove it and go to the next one.
-		reqChain.pop();
-	}
-}
-
-dojo._xdWatchInFlight = function(){
-	//summary: Internal xd loader function.
-	//Monitors in-flight requests for xd module resources.
-
-	var noLoads = "";
-	var waitInterval = (dojo.config.xdWaitSeconds || 15) * 1000;
-	var expired = (dojo._xdStartTime + waitInterval) < (new Date()).getTime();
-
-	//If any xdInFlight are true, then still waiting for something to load.
-	//Come back later. If we timed out, report the things that did not load.
-	for(var param in dojo._xdInFlight){
-		if(dojo._xdInFlight[param] === true){
-			if(expired){
-				noLoads += param + " ";
-			}else{
-				return;
-			}
-		}
-	}
-
-	//All done. Clean up and notify.
-	dojo._xdClearInterval();
-
-	if(expired){
-		throw "Could not load cross-domain resources: " + noLoads;
-	}
-
-	dojo._xdWalkReqs();
-	
-	var defLength = dojo._xdDefList.length;
-	for(var i= 0; i < defLength; i++){
-		var content = dojo._xdDefList[i];
-		if(dojo.config["debugAtAllCosts"] && content["resourceName"]){
-			if(!dojo["_xdDebugQueue"]){
-				dojo._xdDebugQueue = [];
-			}
-			dojo._xdDebugQueue.push({resourceName: content.resourceName, resourcePath: content.resourcePath});
-		}else{
-			//Evaluate the resource to bring it into being.
-			//Pass in scope args to allow multiple versions of modules in a page.
-			content.apply(dojo.global, dojo._scopeArgs);
-		}
-	}
-
-	//Evaluate any resources that were not evaled before.
-	//This normally shouldn't happen with proper dojo.provide and dojo.require
-	//usage, but providing it just in case. Note that these may not be executed
-	//in the original order that the developer intended.
-	for(i = 0; i < dojo._xdContents.length; i++){
-		var current = dojo._xdContents[i];
-		if(current.content && !current.isDefined){
-			//Pass in scope args to allow multiple versions of modules in a page.
-			current.content.apply(dojo.global, dojo._scopeArgs);
-		}
-	}
-
-	//Clean up for the next round of xd loading.
-	dojo._xdReset();
-
-	if(dojo["_xdDebugQueue"] && dojo._xdDebugQueue.length > 0){
-		dojo._xdDebugFileLoaded();
-	}else{
-		dojo._xdNotifyLoaded();
-	}
-}
-
-dojo._xdNotifyLoaded = function(){
-	//Clear inflight count so we will finally do finish work.
-
-	//Just having a legitimate status (true or false) for an inflight item
-	//means that it is still being processed. Do the typeof test
-	//to avoid bad JavaScript that might tinker with Object.prototype.
-	for(var prop in dojo._xdInFlight){
-		if(typeof dojo._xdInFlight[prop] == "boolean"){
-			return;
-		}
-	}
-
-	dojo._inFlightCount = 0;
-
-	//Only trigger call loaded if dj_load_init has run.
-	if(dojo._initFired && !dojo._loadNotifying){
-		dojo._callLoaded();
-	}
-}
-
-}
diff --git a/lib/dojo/_base/array.js b/lib/dojo/_base/array.js
index 57cea4229..f25c2ad00 100644
--- a/lib/dojo/_base/array.js
+++ b/lib/dojo/_base/array.js
@@ -4,260 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.array"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.array"] = true;
-dojo.provide("dojo._base.array");
-dojo.require("dojo._base.lang");
-
-
-(function(){
-	var _getParts = function(arr, obj, cb){
-		return [
-			(typeof arr == "string") ? arr.split("") : arr,
-			obj || dojo.global,
-			// FIXME: cache the anonymous functions we create here?
-			(typeof cb == "string") ? new Function("item", "index", "array", cb) : cb
-		];
-	};
-
-	var everyOrSome = function(/*Boolean*/every, /*Array|String*/arr, /*Function|String*/callback, /*Object?*/thisObject){
-		var _p = _getParts(arr, thisObject, callback); arr = _p[0];
-		for(var i=0,l=arr.length; i<l; ++i){
-			var result = !!_p[2].call(_p[1], arr[i], i, arr);
-			if(every ^ result){
-				return result; // Boolean
-			}
-		}
-		return every; // Boolean
-	};
-
-	dojo.mixin(dojo, {
-		indexOf: function(	/*Array*/		array,
-							/*Object*/		value,
-							/*Integer?*/	fromIndex,
-							/*Boolean?*/	findLast){
-			// summary:
-			//		locates the first index of the provided value in the
-			//		passed array. If the value is not found, -1 is returned.
-			// description:
-			//		This method corresponds to the JavaScript 1.6 Array.indexOf method, with one difference: when
-			//		run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript
-			//		1.6's indexOf skips the holes in the sparse array.
-			//		For details on this method, see:
-			//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
-
-			var step = 1, end = array.length || 0, i = 0;
-			if(findLast){
-				i = end - 1;
-				step = end = -1;
-			}
-			if(fromIndex != undefined){ i = fromIndex; }
-			if((findLast && i > end) || i < end){
-				for(; i != end; i += step){
-					if(array[i] == value){ return i; }
-				}
-			}
-			return -1;	// Number
-		},
-
-		lastIndexOf: function(/*Array*/array, /*Object*/value, /*Integer?*/fromIndex){
-			// summary:
-			//		locates the last index of the provided value in the passed
-			//		array. If the value is not found, -1 is returned.
-			// description:
-			//		This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with one difference: when
-			//		run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript
-			//		1.6's lastIndexOf skips the holes in the sparse array.
-			//		For details on this method, see:
-			// 			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/lastIndexOf
-			return dojo.indexOf(array, value, fromIndex, true); // Number
-		},
-
-		forEach: function(/*Array|String*/arr, /*Function|String*/callback, /*Object?*/thisObject){
-			//	summary:
-			//		for every item in arr, callback is invoked. Return values are ignored.
-			//		If you want to break out of the loop, consider using dojo.every() or dojo.some().
-			//		forEach does not allow breaking out of the loop over the items in arr.
-			//	arr:
-			//		the array to iterate over. If a string, operates on individual characters.
-			//	callback:
-			//		a function is invoked with three arguments: item, index, and array
-			//	thisObject:
-			//		may be used to scope the call to callback
-			//	description:
-			//		This function corresponds to the JavaScript 1.6 Array.forEach() method, with one difference: when
-			//		run over sparse arrays, this implemenation passes the "holes" in the sparse array to
-			//		the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array.
-			//		For more details, see:
-			//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach
-			//	example:
-			//	|	// log out all members of the array:
-			//	|	dojo.forEach(
-			//	|		[ "thinger", "blah", "howdy", 10 ],
-			//	|		function(item){
-			//	|			console.log(item);
-			//	|		}
-			//	|	);
-			//	example:
-			//	|	// log out the members and their indexes
-			//	|	dojo.forEach(
-			//	|		[ "thinger", "blah", "howdy", 10 ],
-			//	|		function(item, idx, arr){
-			//	|			console.log(item, "at index:", idx);
-			//	|		}
-			//	|	);
-			//	example:
-			//	|	// use a scoped object member as the callback
-			//	|
-			//	|	var obj = {
-			//	|		prefix: "logged via obj.callback:",
-			//	|		callback: function(item){
-			//	|			console.log(this.prefix, item);
-			//	|		}
-			//	|	};
-			//	|
-			//	|	// specifying the scope function executes the callback in that scope
-			//	|	dojo.forEach(
-			//	|		[ "thinger", "blah", "howdy", 10 ],
-			//	|		obj.callback,
-			//	|		obj
-			//	|	);
-			//	|
-			//	|	// alternately, we can accomplish the same thing with dojo.hitch()
-			//	|	dojo.forEach(
-			//	|		[ "thinger", "blah", "howdy", 10 ],
-			//	|		dojo.hitch(obj, "callback")
-			//	|	);
-
-			// match the behavior of the built-in forEach WRT empty arrs
-			if(!arr || !arr.length){ return; }
-
-			// FIXME: there are several ways of handilng thisObject. Is
-			// dojo.global always the default context?
-			var _p = _getParts(arr, thisObject, callback); arr = _p[0];
-			for(var i=0,l=arr.length; i<l; ++i){
-				_p[2].call(_p[1], arr[i], i, arr);
-			}
-		},
-
-		every: function(/*Array|String*/arr, /*Function|String*/callback, /*Object?*/thisObject){
-			// summary:
-			//		Determines whether or not every item in arr satisfies the
-			//		condition implemented by callback.
-			// arr:
-			//		the array to iterate on. If a string, operates on individual characters.
-			// callback:
-			//		a function is invoked with three arguments: item, index,
-			//		and array and returns true if the condition is met.
-			// thisObject:
-			//		may be used to scope the call to callback
-			// description:
-			//		This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when
-			//		run over sparse arrays, this implemenation passes the "holes" in the sparse array to
-			//		the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array.
-			//		For more details, see:
-			//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
-			// example:
-			//	|	// returns false
-			//	|	dojo.every([1, 2, 3, 4], function(item){ return item>1; });
-			// example:
-			//	|	// returns true
-			//	|	dojo.every([1, 2, 3, 4], function(item){ return item>0; });
-			return everyOrSome(true, arr, callback, thisObject); // Boolean
-		},
-
-		some: function(/*Array|String*/arr, /*Function|String*/callback, /*Object?*/thisObject){
-			// summary:
-			//		Determines whether or not any item in arr satisfies the
-			//		condition implemented by callback.
-			// arr:
-			//		the array to iterate over. If a string, operates on individual characters.
-			// callback:
-			//		a function is invoked with three arguments: item, index,
-			//		and array and returns true if the condition is met.
-			// thisObject:
-			//		may be used to scope the call to callback
-			// description:
-			//		This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when
-			//		run over sparse arrays, this implemenation passes the "holes" in the sparse array to
-			//		the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array.
-			//		For more details, see:
-			//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
-			// example:
-			//	|	// is true
-			//	|	dojo.some([1, 2, 3, 4], function(item){ return item>1; });
-			// example:
-			//	|	// is false
-			//	|	dojo.some([1, 2, 3, 4], function(item){ return item<1; });
-			return everyOrSome(false, arr, callback, thisObject); // Boolean
-		},
-
-		map: function(/*Array|String*/arr, /*Function|String*/callback, /*Function?*/thisObject){
-			// summary:
-			//		applies callback to each element of arr and returns
-			//		an Array with the results
-			// arr:
-			//		the array to iterate on. If a string, operates on
-			//		individual characters.
-			// callback:
-			//		a function is invoked with three arguments, (item, index,
-			//		array),  and returns a value
-			// thisObject:
-			//		may be used to scope the call to callback
-			// description:
-			//		This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when
-			//		run over sparse arrays, this implemenation passes the "holes" in the sparse array to
-			//		the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array.
-			//		For more details, see:
-			//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
-			// example:
-			//	|	// returns [2, 3, 4, 5]
-			//	|	dojo.map([1, 2, 3, 4], function(item){ return item+1 });
-
-			var _p = _getParts(arr, thisObject, callback); arr = _p[0];
-			var outArr = (arguments[3] ? (new arguments[3]()) : []);
-			for(var i=0,l=arr.length; i<l; ++i){
-				outArr.push(_p[2].call(_p[1], arr[i], i, arr));
-			}
-			return outArr; // Array
-		},
-
-		filter: function(/*Array*/arr, /*Function|String*/callback, /*Object?*/thisObject){
-			// summary:
-			//		Returns a new Array with those items from arr that match the
-			//		condition implemented by callback.
-			// arr:
-			//		the array to iterate over.
-			// callback:
-			//		a function that is invoked with three arguments (item,
-			//		index, array). The return of this function is expected to
-			//		be a boolean which determines whether the passed-in item
-			//		will be included in the returned array.
-			// thisObject:
-			//		may be used to scope the call to callback
-			// description:
-			//		This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when
-			//		run over sparse arrays, this implemenation passes the "holes" in the sparse array to
-			//		the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array.
-			//		For more details, see:
-			//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
-			// example:
-			//	|	// returns [2, 3, 4]
-			//	|	dojo.filter([1, 2, 3, 4], function(item){ return item>1; });
-
-			var _p = _getParts(arr, thisObject, callback); arr = _p[0];
-			var outArr = [];
-			for(var i=0,l=arr.length; i<l; ++i){
-				if(_p[2].call(_p[1], arr[i], i, arr)){
-					outArr.push(arr[i]);
-				}
-			}
-			return outArr; // Array
-		}
-	});
-})();
-/*
-*/
-
-}
+//>>built
+define("dojo/_base/array",["./kernel","../has","./lang"],function(_1,_2,_3){var _4={},u,_5;function _6(){_4={};};function _7(fn){return _4[fn]=new Function("item","index","array",fn);};function _8(_9){var _a=!_9;return function(a,fn,o){var i=0,l=a&&a.length||0,_b;if(l&&typeof a=="string"){a=a.split("");}if(typeof fn=="string"){fn=_4[fn]||_7(fn);}if(o){for(;i<l;++i){_b=!fn.call(o,a[i],i,a);if(_9^_b){return !_b;}}}else{for(;i<l;++i){_b=!fn(a[i],i,a);if(_9^_b){return !_b;}}}return _a;};};function _c(up){var _d=1,_e=0,_f=0;if(!up){_d=_e=_f=-1;}return function(a,x,_10,_11){if(_11&&_d>0){return _5.lastIndexOf(a,x,_10);}var l=a&&a.length||0,end=up?l+_f:_e,i;if(_10===u){i=up?_e:l+_f;}else{if(_10<0){i=l+_10;if(i<0){i=_e;}}else{i=_10>=l?l+_f:_10;}}if(l&&typeof a=="string"){a=a.split("");}for(;i!=end;i+=_d){if(a[i]==x){return i;}}return -1;};};function _12(a,fn,o){var i=0,l=a&&a.length||0;if(l&&typeof a=="string"){a=a.split("");}if(typeof fn=="string"){fn=_4[fn]||_7(fn);}if(o){for(;i<l;++i){fn.call(o,a[i],i,a);}}else{for(;i<l;++i){fn(a[i],i,a);}}};function map(a,fn,o,Ctr){var i=0,l=a&&a.length||0,out=new (Ctr||Array)(l);if(l&&typeof a=="string"){a=a.split("");}if(typeof fn=="string"){fn=_4[fn]||_7(fn);}if(o){for(;i<l;++i){out[i]=fn.call(o,a[i],i,a);}}else{for(;i<l;++i){out[i]=fn(a[i],i,a);}}return out;};function _13(a,fn,o){var i=0,l=a&&a.length||0,out=[],_14;if(l&&typeof a=="string"){a=a.split("");}if(typeof fn=="string"){fn=_4[fn]||_7(fn);}if(o){for(;i<l;++i){_14=a[i];if(fn.call(o,_14,i,a)){out.push(_14);}}}else{for(;i<l;++i){_14=a[i];if(fn(_14,i,a)){out.push(_14);}}}return out;};_5={every:_8(false),some:_8(true),indexOf:_c(true),lastIndexOf:_c(false),forEach:_12,map:map,filter:_13,clearCache:_6};1&&_3.mixin(_1,_5);return _5;});
\ No newline at end of file
diff --git a/lib/dojo/_base/array.js.uncompressed.js b/lib/dojo/_base/array.js.uncompressed.js
new file mode 100644
index 000000000..06e733b4b
--- /dev/null
+++ b/lib/dojo/_base/array.js.uncompressed.js
@@ -0,0 +1,343 @@
+define("dojo/_base/array", ["./kernel", "../has", "./lang"], function(dojo, has, lang){
+	// module:
+	//		dojo/_base/array
+	// summary:
+	//		This module defines the Javascript v1.6 array extensions.
+
+	/*=====
+	dojo.indexOf = function(arr, value, fromIndex, findLast){
+		// summary:
+		//		locates the first index of the provided value in the
+		//		passed array. If the value is not found, -1 is returned.
+		// description:
+		//		This method corresponds to the JavaScript 1.6 Array.indexOf method, with one difference: when
+		//		run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript
+		//		1.6's indexOf skips the holes in the sparse array.
+		//		For details on this method, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
+		// arr: Array
+		// value: Object
+		// fromIndex: Integer?
+		// findLast: Boolean?
+		// returns: Number
+	};
+	dojo.lastIndexOf = function(arr, value, fromIndex){
+		// summary:
+		//		locates the last index of the provided value in the passed
+		//		array. If the value is not found, -1 is returned.
+		// description:
+		//		This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with one difference: when
+		//		run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript
+		//		1.6's lastIndexOf skips the holes in the sparse array.
+		//		For details on this method, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/lastIndexOf
+		//	arr: Array,
+		//	value: Object,
+		//	fromIndex: Integer?
+		//	returns: Number
+	};
+	dojo.forEach = function(arr, callback, thisObject){
+		//	summary:
+		//		for every item in arr, callback is invoked. Return values are ignored.
+		//		If you want to break out of the loop, consider using dojo.every() or dojo.some().
+		//		forEach does not allow breaking out of the loop over the items in arr.
+		//	arr:
+		//		the array to iterate over. If a string, operates on individual characters.
+		//	callback:
+		//		a function is invoked with three arguments: item, index, and array
+		//	thisObject:
+		//		may be used to scope the call to callback
+		//	description:
+		//		This function corresponds to the JavaScript 1.6 Array.forEach() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach
+		//	example:
+		//	| // log out all members of the array:
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		function(item){
+		//	|			console.log(item);
+		//	|		}
+		//	| );
+		//	example:
+		//	| // log out the members and their indexes
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		function(item, idx, arr){
+		//	|			console.log(item, "at index:", idx);
+		//	|		}
+		//	| );
+		//	example:
+		//	| // use a scoped object member as the callback
+		//	|
+		//	| var obj = {
+		//	|		prefix: "logged via obj.callback:",
+		//	|		callback: function(item){
+		//	|			console.log(this.prefix, item);
+		//	|		}
+		//	| };
+		//	|
+		//	| // specifying the scope function executes the callback in that scope
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		obj.callback,
+		//	|		obj
+		//	| );
+		//	|
+		//	| // alternately, we can accomplish the same thing with dojo.hitch()
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		dojo.hitch(obj, "callback")
+		//	| );
+		//	arr: Array|String
+		//	callback: Function|String
+		//	thisObject: Object?
+	};
+	dojo.every = function(arr, callback, thisObject){
+		// summary:
+		//		Determines whether or not every item in arr satisfies the
+		//		condition implemented by callback.
+		// arr: Array|String
+		//		the array to iterate on. If a string, operates on individual characters.
+		// callback: Function|String
+		//		a function is invoked with three arguments: item, index,
+		//		and array and returns true if the condition is met.
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Boolean
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
+		// example:
+		//	| // returns false
+		//	| dojo.every([1, 2, 3, 4], function(item){ return item>1; });
+		// example:
+		//	| // returns true
+		//	| dojo.every([1, 2, 3, 4], function(item){ return item>0; });
+	};
+	dojo.some = function(arr, callback, thisObject){
+		// summary:
+		//		Determines whether or not any item in arr satisfies the
+		//		condition implemented by callback.
+		// arr: Array|String
+		//		the array to iterate over. If a string, operates on individual characters.
+		// callback: Function|String
+		//		a function is invoked with three arguments: item, index,
+		//		and array and returns true if the condition is met.
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Boolean
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
+		// example:
+		//	| // is true
+		//	| dojo.some([1, 2, 3, 4], function(item){ return item>1; });
+		// example:
+		//	| // is false
+		//	| dojo.some([1, 2, 3, 4], function(item){ return item<1; });
+	};
+	dojo.map = function(arr, callback, thisObject){
+		// summary:
+		//		applies callback to each element of arr and returns
+		//		an Array with the results
+		// arr: Array|String
+		//		the array to iterate on. If a string, operates on
+		//		individual characters.
+		// callback: Function|String
+		//		a function is invoked with three arguments, (item, index,
+		//		array),	 and returns a value
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Array
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
+		// example:
+		//	| // returns [2, 3, 4, 5]
+		//	| dojo.map([1, 2, 3, 4], function(item){ return item+1 });
+	};
+	dojo.filter = function(arr, callback, thisObject){
+		// summary:
+		//		Returns a new Array with those items from arr that match the
+		//		condition implemented by callback.
+		// arr: Array
+		//		the array to iterate over.
+		// callback: Function|String
+		//		a function that is invoked with three arguments (item,
+		//		index, array). The return of this function is expected to
+		//		be a boolean which determines whether the passed-in item
+		//		will be included in the returned array.
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Array
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
+		// example:
+		//	| // returns [2, 3, 4]
+		//	| dojo.filter([1, 2, 3, 4], function(item){ return item>1; });
+	};
+	=====*/
+
+	// our old simple function builder stuff
+	var cache = {}, u, array; // the export object
+
+	function clearCache(){
+		cache = {};
+	}
+
+	function buildFn(fn){
+		return cache[fn] = new Function("item", "index", "array", fn); // Function
+	}
+	// magic snippet: if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+
+	// every & some
+
+	function everyOrSome(some){
+		var every = !some;
+		return function(a, fn, o){
+			var i = 0, l = a && a.length || 0, result;
+			if(l && typeof a == "string") a = a.split("");
+			if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+			if(o){
+				for(; i < l; ++i){
+					result = !fn.call(o, a[i], i, a);
+					if(some ^ result){
+						return !result;
+					}
+				}
+			}else{
+				for(; i < l; ++i){
+					result = !fn(a[i], i, a);
+					if(some ^ result){
+						return !result;
+					}
+				}
+			}
+			return every; // Boolean
+		}
+	}
+	// var every = everyOrSome(false), some = everyOrSome(true);
+
+	// indexOf, lastIndexOf
+
+	function index(up){
+		var delta = 1, lOver = 0, uOver = 0;
+		if(!up){
+			delta = lOver = uOver = -1;
+		}
+		return function(a, x, from, last){
+			if(last && delta > 0){
+				// TODO: why do we use a non-standard signature? why do we need "last"?
+				return array.lastIndexOf(a, x, from);
+			}
+			var l = a && a.length || 0, end = up ? l + uOver : lOver, i;
+			if(from === u){
+				i = up ? lOver : l + uOver;
+			}else{
+				if(from < 0){
+					i = l + from;
+					if(i < 0){
+						i = lOver;
+					}
+				}else{
+					i = from >= l ? l + uOver : from;
+				}
+			}
+			if(l && typeof a == "string") a = a.split("");
+			for(; i != end; i += delta){
+				if(a[i] == x){
+					return i; // Number
+				}
+			}
+			return -1; // Number
+		}
+	}
+	// var indexOf = index(true), lastIndexOf = index(false);
+
+	function forEach(a, fn, o){
+		var i = 0, l = a && a.length || 0;
+		if(l && typeof a == "string") a = a.split("");
+		if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+		if(o){
+			for(; i < l; ++i){
+				fn.call(o, a[i], i, a);
+			}
+		}else{
+			for(; i < l; ++i){
+				fn(a[i], i, a);
+			}
+		}
+	}
+
+	function map(a, fn, o, Ctr){
+		// TODO: why do we have a non-standard signature here? do we need "Ctr"?
+		var i = 0, l = a && a.length || 0, out = new (Ctr || Array)(l);
+		if(l && typeof a == "string") a = a.split("");
+		if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+		if(o){
+			for(; i < l; ++i){
+				out[i] = fn.call(o, a[i], i, a);
+			}
+		}else{
+			for(; i < l; ++i){
+				out[i] = fn(a[i], i, a);
+			}
+		}
+		return out; // Array
+	}
+
+	function filter(a, fn, o){
+		// TODO: do we need "Ctr" here like in map()?
+		var i = 0, l = a && a.length || 0, out = [], value;
+		if(l && typeof a == "string") a = a.split("");
+		if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+		if(o){
+			for(; i < l; ++i){
+				value = a[i];
+				if(fn.call(o, value, i, a)){
+					out.push(value);
+				}
+			}
+		}else{
+			for(; i < l; ++i){
+				value = a[i];
+				if(fn(value, i, a)){
+					out.push(value);
+				}
+			}
+		}
+		return out; // Array
+	}
+
+	array = {
+		every:       everyOrSome(false),
+		some:        everyOrSome(true),
+		indexOf:     index(true),
+		lastIndexOf: index(false),
+		forEach:     forEach,
+		map:         map,
+		filter:      filter,
+		clearCache:  clearCache
+	};
+
+	1 && lang.mixin(dojo, array);
+
+	/*===== return dojo.array; =====*/
+	return array;
+});
diff --git a/lib/dojo/_base/browser.js b/lib/dojo/_base/browser.js
index 209330f0d..69d57f4cf 100644
--- a/lib/dojo/_base/browser.js
+++ b/lib/dojo/_base/browser.js
@@ -4,25 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.browser"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.browser"] = true;
-dojo.provide("dojo._base.browser");
-dojo.require("dojo._base.window");
-dojo.require("dojo._base.connect");
-dojo.require("dojo._base.event");
-dojo.require("dojo._base.html");
-dojo.require("dojo._base.NodeList");
-dojo.require("dojo._base.query");
-dojo.require("dojo._base.xhr");
-dojo.require("dojo._base.fx");
-
-	//Need this to be the last code segment in base, so do not place any
-	//dojo/requireIf calls in this file/ Otherwise, due to how the build system
-	//puts all requireIf dependencies after the current file, the require calls
-	//could be called before all of base is defined/
-	dojo.forEach(dojo.config.require, function(i){
-		dojo["require"](i);
-	});
-
-}
+//>>built
+if(require.has){require.has.add("config-selectorEngine","acme");}define("dojo/_base/browser",["../ready","./kernel","./connect","./unload","./window","./event","./html","./NodeList","../query","./xhr","./fx"],function(_1){return _1;});
\ No newline at end of file
diff --git a/lib/dojo/_base/browser.js.uncompressed.js b/lib/dojo/_base/browser.js.uncompressed.js
new file mode 100644
index 000000000..8f186e2a1
--- /dev/null
+++ b/lib/dojo/_base/browser.js.uncompressed.js
@@ -0,0 +1,21 @@
+if(require.has){
+	require.has.add("config-selectorEngine", "acme");
+}
+define("dojo/_base/browser", [
+	"../ready",
+	"./kernel",
+	"./connect", // until we decide if connect is going back into non-browser environments
+	"./unload",
+	"./window",
+	"./event",
+	"./html",
+	"./NodeList",
+	"../query",
+	"./xhr",
+	"./fx"], function(dojo) {
+	// module:
+	//		dojo/_base/browser
+	// summary:
+	//		This module causes the browser-only base modules to be loaded.
+	return dojo;
+});
diff --git a/lib/dojo/_base/config.js b/lib/dojo/_base/config.js
new file mode 100644
index 000000000..5c70ffd91
--- /dev/null
+++ b/lib/dojo/_base/config.js
@@ -0,0 +1,8 @@
+/*
+	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
+*/
+
+//>>built
+define("dojo/_base/config",["../has","require"],function(_1,_2){var _3={};if(1){var _4=_2.rawConfig,p;for(p in _4){_3[p]=_4[p];}}else{var _5=function(_6,_7,_8){for(p in _6){p!="has"&&_1.add(_7+p,_6[p],0,_8);}};_3=1?_2.rawConfig:this.dojoConfig||this.djConfig||{};_5(_3,"config",1);_5(_3.has,"",1);}return _3;});
\ No newline at end of file
diff --git a/lib/dojo/_base/config.js.uncompressed.js b/lib/dojo/_base/config.js.uncompressed.js
new file mode 100644
index 000000000..290efd10a
--- /dev/null
+++ b/lib/dojo/_base/config.js.uncompressed.js
@@ -0,0 +1,174 @@
+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
+}
+=====*/
+});
+
diff --git a/lib/dojo/_base/_loader/hostenv_ff_ext.js b/lib/dojo/_base/configFirefoxExtension.js
index ca47a4c1c..ce30c9153 100644
--- a/lib/dojo/_base/_loader/hostenv_ff_ext.js
+++ b/lib/dojo/_base/configFirefoxExtension.js
@@ -1,9 +1,4 @@
-/*
-	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
-*/
-
+// TODO: this file needs to be converted to the v1.7 loader
 
 // a host environment specifically built for Mozilla extensions, but derived
 // from the browser host environment
@@ -18,13 +13,12 @@ if(typeof window != 'undefined'){
 
 	// attempt to figure out the path to dojo if it isn't set in the config
 	(function(){
-		var d = dojo;
 		// this is a scope protection closure. We set browser versions and grab
 		// the URL we were loaded from here.
 
 		// FIXME: need to probably use a different reference to "document" to get the hosting XUL environment
 
-		d.baseUrl = d.config.baseUrl;
+		dojo.baseUrl = dojo.config.baseUrl;
 
 		// fill in the rendering support information in dojo.render.*
 		var n = navigator;
@@ -32,25 +26,25 @@ if(typeof window != 'undefined'){
 		var dav = n.appVersion;
 		var tv = parseFloat(dav);
 
-		d.isMozilla = d.isMoz = tv;
-		if(d.isMoz){
-			d.isFF = parseFloat(dua.split("Firefox/")[1]) || undefined;
+		dojo.isMozilla = dojo.isMoz = tv;
+		if(dojo.isMoz){
+			dojo.isFF = parseFloat(dua.split("Firefox/")[1]) || undefined;
 		}
 
 		// FIXME
-		d.isQuirks = document.compatMode == "BackCompat";
+		dojo.isQuirks = document.compatMode == "BackCompat";
 
 		// FIXME
 		// TODO: is the HTML LANG attribute relevant?
-		d.locale = dojo.config.locale || n.language.toLowerCase();
+		dojo.locale = dojo.config.locale || n.language.toLowerCase();
 
-		d._xhrObj = function(){
+		dojo._xhrObj = function(){
 			return new XMLHttpRequest();
-		}
+		};
 
 		// monkey-patch _loadUri to handle file://, chrome://, and resource:// url's
-		var oldLoadUri = d._loadUri;
-		d._loadUri = function(uri, cb){
+		var oldLoadUri = dojo._loadUri;
+		dojo._loadUri = function(uri, cb){
 			var handleLocal = ["file:", "chrome:", "resource:"].some(function(prefix){
 				return String(uri).indexOf(prefix) == 0;
 			});
@@ -59,23 +53,23 @@ if(typeof window != 'undefined'){
 				//		http://developer.mozilla.org/en/mozIJSSubScriptLoader
 				var l = Components.classes["@mozilla.org/moz/jssubscript-loader;1"]
 					.getService(Components.interfaces.mozIJSSubScriptLoader);
-				var value = l.loadSubScript(uri, d.global)
+				var value = l.loadSubScript(uri, dojo.global);
 				if(cb){ cb(value); }
 				return true;
 			}else{
 				// otherwise, call the pre-existing version
-				return oldLoadUri.apply(d, arguments);
+				return oldLoadUri.apply(dojo, arguments);
 			}
-		}
+		};
 
 		// FIXME: PORTME
-		d._isDocumentOk = function(http){
+		dojo._isDocumentOk = function(http){
 			var stat = http.status || 0;
 			return (stat >= 200 && stat < 300) || 	// Boolean
 				stat == 304 || 						// allow any 2XX response code
 				stat == 1223 || 						// get it out of the cache
-				(!stat && (location.protocol=="file:" || location.protocol=="chrome:") );
-		}
+				(!stat && (location.protocol == "file:" || location.protocol == "chrome:") );
+		};
 
 		// FIXME: PORTME
 		// var owloc = window.location+"";
@@ -83,7 +77,7 @@ if(typeof window != 'undefined'){
 		// var hasBase = (base && base.length > 0);
 		var hasBase = false;
 
-		d._getText = function(/*URI*/ uri, /*Boolean*/ fail_ok){
+		dojo._getText = function(/*URI*/ uri, /*Boolean*/ fail_ok){
 			// summary: Read the contents of the specified uri and return those contents.
 			// uri:
 			//		A relative or absolute uri. If absolute, it still must be in
@@ -97,15 +91,15 @@ if(typeof window != 'undefined'){
 			// alert("_getText: " + uri);
 
 			// NOTE: must be declared before scope switches ie. this._xhrObj()
-			var http = d._xhrObj();
+			var http = dojo._xhrObj();
 
 			if(!hasBase && dojo._Url){
 				uri = (new dojo._Url(uri)).toString();
 			}
-			if(d.config.cacheBust){
+			if(dojo.config.cacheBust){
 				//Make sure we have a string before string methods are used on uri
 				uri += "";
-				uri += (uri.indexOf("?") == -1 ? "?" : "&") + String(d.config.cacheBust).replace(/\W+/g,"");
+				uri += (uri.indexOf("?") == -1 ? "?" : "&") + String(dojo.config.cacheBust).replace(/\W+/g, "");
 			}
 			var handleLocal = ["file:", "chrome:", "resource:"].some(function(prefix){
 				return String(uri).indexOf(prefix) == 0;
@@ -115,7 +109,7 @@ if(typeof window != 'undefined'){
 				//		http://forums.mozillazine.org/viewtopic.php?p=921150#921150
 				var ioService = Components.classes["@mozilla.org/network/io-service;1"]
 					.getService(Components.interfaces.nsIIOService);
-				var scriptableStream=Components
+				var scriptableStream = Components
 					.classes["@mozilla.org/scriptableinputstream;1"]
 					.getService(Components.interfaces.nsIScriptableInputStream);
 
@@ -131,37 +125,39 @@ if(typeof window != 'undefined'){
 				try{
 					http.send(null);
 					// alert(http);
-					if(!d._isDocumentOk(http)){
-						var err = Error("Unable to load "+uri+" status:"+ http.status);
+					if(!dojo._isDocumentOk(http)){
+						var err = Error("Unable to load " + uri + " status:" + http.status);
 						err.status = http.status;
 						err.responseText = http.responseText;
 						throw err;
 					}
 				}catch(e){
-					if(fail_ok){ return null; } // null
+					if(fail_ok){
+						return null;
+					} // null
 					// rethrow the exception
 					throw e;
 				}
 				return http.responseText; // String
 			}
-		}
-		
-		d._windowUnloaders = [];
-		
+		};
+
+		dojo._windowUnloaders = [];
+
 		// FIXME: PORTME
-		d.windowUnloaded = function(){
+		dojo.windowUnloaded = function(){
 			// summary:
 			//		signal fired by impending window destruction. You may use
 			//		dojo.addOnWIndowUnload() or dojo.connect() to this method to perform
 			//		page/application cleanup methods. See dojo.addOnWindowUnload for more info.
-			var mll = d._windowUnloaders;
+			var mll = dojo._windowUnloaders;
 			while(mll.length){
 				(mll.pop())();
 			}
-		}
+		};
 
 		// FIXME: PORTME
-		d.addOnWindowUnload = function(/*Object?*/obj, /*String|Function?*/functionName){
+		dojo.addOnWindowUnload = function(/*Object?*/obj, /*String|Function?*/functionName){
 			// summary:
 			//		registers a function to be triggered when window.onunload fires.
 			//		Be careful trying to modify the DOM or access JavaScript properties
@@ -172,9 +168,9 @@ if(typeof window != 'undefined'){
 			//	|	dojo.addOnWindowUnload(functionPointer)
 			//	|	dojo.addOnWindowUnload(object, "functionName")
 			//	|	dojo.addOnWindowUnload(object, function(){ /* ... */});
-	
-			d._onto(d._windowUnloaders, obj, functionName);
-		}
+
+			dojo._onto(dojo._windowUnloaders, obj, functionName);
+		};
 
 		// XUL specific APIs
 		var contexts = [];
@@ -271,7 +267,7 @@ if(typeof window != 'undefined'){
 		if(dojo._inFlightCount == 0){
 			dojo._modulesLoaded();
 		}
-	}
+	};
 
 	/*
 	(function(){
@@ -294,7 +290,7 @@ if(typeof window != 'undefined'){
 		_handleNodeEvent("onunload", function() { dojo.windowUnloaded(); });
 	})();
 	*/
-	
+
 
 	//	FIXME: PORTME
 	// 		this event fires a lot, namely for all plugin XUL overlays and for
@@ -302,7 +298,7 @@ if(typeof window != 'undefined'){
 	// 		Dojo's to fire once..but we might care if pages navigate. We'll
 	// 		probably need an extension-specific API
 	if(!dojo.config.afterOnLoad){
-		window.addEventListener("DOMContentLoaded",function(e){
+		window.addEventListener("DOMContentLoaded", function(e){
 			dojo._loadInit(e);
 			// console.log("DOM content loaded", e);
 		}, false);
@@ -328,11 +324,11 @@ if(dojo.config.isDebug){
 	console.log = function(m){
 		var s = Components.classes["@mozilla.org/consoleservice;1"].getService(
 			Components.interfaces.nsIConsoleService
-		);
+			);
 		s.logStringMessage(m);
-	}
+	};
 	console.debug = function(){
 		console.log(dojo._toArray(arguments).join(" "));
-	}
+	};
 	// FIXME: what about the rest of the console.* methods? And is there any way to reach into firebug and log into it directly?
 }
diff --git a/lib/dojo/_base/configNode.js b/lib/dojo/_base/configNode.js
new file mode 100644
index 000000000..7cd6f14f9
--- /dev/null
+++ b/lib/dojo/_base/configNode.js
@@ -0,0 +1,87 @@
+exports.config = function(config){
+	//	summary:
+	//		This module provides bootstrap configuration for running dojo in node.js
+
+	// any command line arguments with the load flag are pushed into deps
+	for(var deps = [], args = [], i = 0; i < process.argv.length; i++){
+		var arg = (process.argv[i] + "").split("=");
+		if(arg[0] == "load"){
+			deps.push(arg[1]);
+		}else{
+			args.push(arg);
+		}
+	}
+
+	var fs = require("fs");
+
+	// make sure global require exists
+	//if (typeof global.require=="undefined") {
+	//	global.require= {};
+	//}
+
+	// reset the has cache with node-appropriate values;
+	var hasCache = {
+		"host-node":1,
+		"host-browser":0,
+		"dom":0,
+		"dojo-has-api":1,
+		"dojo-xhr-factory":0,
+		"dojo-inject-api":1,
+		"dojo-timeout-api":0,
+		"dojo-trace-api":1,
+		"dojo-dom-ready-api":0,
+		"dojo-publish-privates":1,
+		"dojo-sniff":0,
+		"dojo-loader":1,
+		"dojo-test-xd":0,
+		"dojo-test-sniff":0
+	};
+	for(var p in hasCache){
+		config.hasCache[p] = hasCache[p];
+	}
+
+	var vm = require('vm');
+
+
+	// reset some configuration switches with node-appropriate values
+	var nodeConfig = {
+		baseUrl: __dirname.match(/(.+)[\/\\]_base$/)[1],
+		commandLineArgs:args,
+		deps:deps,
+		timeout:0,
+
+		// TODO: really get the locale
+		locale:"en-us",
+
+		loaderPatch: {
+			log:function(item){
+				// define debug for console messages during dev instead of console.log
+				// (node's heavy async makes console.log confusing sometimes)
+				var util = require("util");
+				util.debug(util.inspect(item));
+			},
+
+			eval: function(__text, __urlHint){
+				return vm.runInThisContext(__text, __urlHint);
+			},
+
+			injectUrl: function(url, callback){
+				try{
+					vm.runInThisContext(fs.readFileSync(url, "utf8"), url);
+					callback();
+				}catch(e){
+					this.log("failed to load resource (" + url + ")");
+					this.log(e);
+				}
+			},
+
+			getText: function(url, sync, onLoad){
+				// TODO: implement async and http/https handling
+				onLoad(fs.readFileSync(url, "utf8"));
+			}
+		}
+	};
+	for(p in nodeConfig){
+		config[p] = nodeConfig[p];
+	}
+};
diff --git a/lib/dojo/_base/configRhino.js b/lib/dojo/_base/configRhino.js
new file mode 100644
index 000000000..ec6475997
--- /dev/null
+++ b/lib/dojo/_base/configRhino.js
@@ -0,0 +1,121 @@
+function rhinoDojoConfig(config, baseUrl, rhinoArgs){
+	//	summary:
+	//		This module provides bootstrap configuration for running dojo in rhino.
+
+	// TODO: v1.6 tries to set dojo.doc and dojo.body in rhino; why?
+
+	// get a minimal console up
+	var log = function(hint, args){
+		print((hint ? hint + ":" : "") + args[0]);
+		for(var i = 1; i < args.length; i++){
+			print(", " + args[i]);
+		}
+	};
+	// intentionally define console in the global namespace
+	console= {
+		log: function(){ log(0, arguments); },
+		error: function(){ log("ERROR", arguments); },
+		warn: function(){ log("WARN", arguments); }
+	};
+
+	// any command line arguments with the load flag are pushed into deps
+	for(var deps = [], i = 0; i < rhinoArgs.length; i++){
+		var arg = (rhinoArgs[i] + "").split("=");
+		if(arg[0] == "load"){
+			deps.push(arg[1]);
+		}
+	}
+
+	// provides timed callbacks using Java threads
+	if(typeof setTimeout == "undefined" || typeof clearTimeout == "undefined"){
+		var timeouts = [];
+		clearTimeout = function(idx){
+			if(!timeouts[idx]){ return; }
+			timeouts[idx].stop();
+		};
+
+		setTimeout = function(func, delay){
+			var def = {
+				sleepTime:delay,
+				hasSlept:false,
+
+				run:function(){
+					if(!this.hasSlept){
+						this.hasSlept = true;
+						java.lang.Thread.currentThread().sleep(this.sleepTime);
+					}
+					try{
+						func();
+					}catch(e){
+						console.debug("Error running setTimeout thread:" + e);
+					}
+				}
+			};
+
+			var runnable = new java.lang.Runnable(def);
+			var thread = new java.lang.Thread(runnable);
+			thread.start();
+			return timeouts.push(thread) - 1;
+		};
+	}
+
+	var isLocal = function(url){
+		return (new java.io.File(url)).exists();
+	};
+
+	// reset the has cache with node-appropriate values;
+	var hasCache = {
+		"host-rhino":1,
+		"host-browser":0,
+		"dom":0,
+		"dojo-has-api":1,
+		"dojo-xhr-factory":0,
+		"dojo-inject-api":1,
+		"dojo-timeout-api":0,
+		"dojo-trace-api":1,
+		"dojo-loader-catches":1,
+		"dojo-dom-ready-api":0,
+		"dojo-publish-privates":1,
+		"dojo-sniff":0,
+		"dojo-loader":1,
+		"dojo-test-xd":0,
+		"dojo-test-sniff":0
+	};
+	for(var p in hasCache){
+		config.hasCache[p] = hasCache[p];
+	}
+
+	// reset some configuration switches with rhino-appropriate values
+	var rhinoConfig = {
+		baseUrl:baseUrl,
+		commandLineArgs:rhinoArgs,
+		deps:deps,
+		timeout:0,
+		locale:String(java.util.Locale.getDefault().toString().replace('_', '-').toLowerCase()),
+
+		loaderPatch:{
+			injectUrl: function(url, callback){
+				try{
+					if(isLocal(url)){
+						load(url);
+					}else{
+						require.eval(readUrl(url, "UTF-8"));
+					}
+					callback();
+				}catch(e){
+					console.log("failed to load resource (" + url + ")");
+					console.log(e);
+				}
+			},
+
+			getText: function(url, sync, onLoad){
+				// TODO: test https://bugzilla.mozilla.org/show_bug.cgi?id=471005; see v1.6 hostenv_rhino
+				// note: async mode not supported in rhino
+				onLoad(isLocal(url) ? readFile(url, "UTF-8") : readUrl(url, "UTF-8"));
+			}
+		}
+	};
+	for(p in rhinoConfig){
+		config[p] = rhinoConfig[p];
+	}
+}
diff --git a/lib/dojo/_base/_loader/hostenv_spidermonkey.js b/lib/dojo/_base/configSpidermonkey.js
index a3d2dfc6f..0da0d7102 100644
--- a/lib/dojo/_base/_loader/hostenv_spidermonkey.js
+++ b/lib/dojo/_base/configSpidermonkey.js
@@ -1,8 +1,4 @@
-/*
-	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
-*/
+// TODO: this file needs to be converted to the v1.7 loader
 
 
 /*
@@ -26,7 +22,7 @@ dojo.isSpidermonkey = {
 dojo.isSpidermonkey = true;
 dojo.exit = function(exitcode){
 	quit(exitcode);
-}
+};
 
 if(typeof print == "function"){
 	console.debug = print;
@@ -46,24 +42,24 @@ dojo._spidermonkeyCurrentFile = function(depth){
 	//	the stack, but that does require that you know how deep your stack is when you are
 	//	calling.
 	//
-    var s = '';
-    try{
+	var s = '';
+	try{
 		throw Error("whatever");
 	}catch(e){
 		s = e.stack;
 	}
-    // lines are like: bu_getCurrentScriptURI_spidermonkey("ScriptLoader.js")@burst/Runtime.js:101
-    var matches = s.match(/[^@]*\.js/gi);
-    if(!matches){
+	// lines are like: bu_getCurrentScriptURI_spidermonkey("ScriptLoader.js")@burst/Runtime.js:101
+	var matches = s.match(/[^@]*\.js/gi);
+	if(!matches){
 		throw Error("could not parse stack string: '" + s + "'");
 	}
-    var fname = (typeof depth != 'undefined' && depth) ? matches[depth + 1] : matches[matches.length - 1];
-    if(!fname){
+	var fname = (typeof depth != 'undefined' && depth) ? matches[depth + 1] : matches[matches.length - 1];
+	if(!fname){
 		throw Error("could not find file name in stack string '" + s + "'");
 	}
-    //print("SpiderMonkeyRuntime got fname '" + fname + "' from stack string '" + s + "'");
-    return fname;
-}
+	//print("SpiderMonkeyRuntime got fname '" + fname + "' from stack string '" + s + "'");
+	return fname;
+};
 
 // print(dojo._spidermonkeyCurrentFile(0));
 
@@ -72,10 +68,11 @@ dojo._loadUri = function(uri){
 	// is what we want).
 	// TODO: sigh, load() does not return a useful value.
 	// Perhaps it is returning the value of the last thing evaluated?
-	var ok = load(uri);
+	// var ok =
+	load(uri);
 	// console.log("spidermonkey load(", uri, ") returned ", ok);
 	return 1;
-}
+};
 
 //Register any module paths set up in djConfig. Need to do this
 //in the hostenvs since hostenv_browser can read djConfig from a
diff --git a/lib/dojo/_base/connect.js b/lib/dojo/_base/connect.js
index 7e8006221..6fa7aabc3 100644
--- a/lib/dojo/_base/connect.js
+++ b/lib/dojo/_base/connect.js
@@ -4,308 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.connect"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.connect"] = true;
-dojo.provide("dojo._base.connect");
-dojo.require("dojo._base.lang");
-
-
-// this file courtesy of the TurboAjax Group, licensed under a Dojo CLA
-
-// low-level delegation machinery
-dojo._listener = {
-	// create a dispatcher function
-	getDispatcher: function(){
-		// following comments pulled out-of-line to prevent cloning them
-		// in the returned function.
-		// - indices (i) that are really in the array of listeners (ls) will
-		//   not be in Array.prototype. This is the 'sparse array' trick
-		//   that keeps us safe from libs that take liberties with built-in
-		//   objects
-		// - listener is invoked with current scope (this)
-		return function(){
-			var ap = Array.prototype, c = arguments.callee, ls = c._listeners, t = c.target,
-			// return value comes from original target function
-				r = t && t.apply(this, arguments),
-			// make local copy of listener array so it is immutable during processing
-				i, lls = [].concat(ls)
-			;
-
-			// invoke listeners after target function
-			for(i in lls){
-				if(!(i in ap)){
-					lls[i].apply(this, arguments);
-				}
-			}
-			// return value comes from original target function
-			return r;
-		};
-	},
-	// add a listener to an object
-	add: function(/*Object*/ source, /*String*/ method, /*Function*/ listener){
-		// Whenever 'method' is invoked, 'listener' will have the same scope.
-		// Trying to supporting a context object for the listener led to
-		// complexity.
-		// Non trivial to provide 'once' functionality here
-		// because listener could be the result of a dojo.hitch call,
-		// in which case two references to the same hitch target would not
-		// be equivalent.
-		source = source || dojo.global;
-		// The source method is either null, a dispatcher, or some other function
-		var f = source[method];
-		// Ensure a dispatcher
-		if(!f || !f._listeners){
-			var d = dojo._listener.getDispatcher();
-			// original target function is special
-			d.target = f;
-			// dispatcher holds a list of listeners
-			d._listeners = [];
-			// redirect source to dispatcher
-			f = source[method] = d;
-		}
-		// The contract is that a handle is returned that can
-		// identify this listener for disconnect.
-		//
-		// The type of the handle is private. Here is it implemented as Integer.
-		// DOM event code has this same contract but handle is Function
-		// in non-IE browsers.
-		//
-		// We could have separate lists of before and after listeners.
-		return f._listeners.push(listener); /*Handle*/
-	},
-	// remove a listener from an object
-	remove: function(/*Object*/ source, /*String*/ method, /*Handle*/ handle){
-		var f = (source || dojo.global)[method];
-		// remember that handle is the index+1 (0 is not a valid handle)
-		if(f && f._listeners && handle--){
-			delete f._listeners[handle];
-		}
-	}
-};
-
-// Multiple delegation for arbitrary methods.
-
-// This unit knows nothing about DOM, but we include DOM aware documentation
-// and dontFix argument here to help the autodocs. Actual DOM aware code is in
-// event.js.
-
-dojo.connect = function(/*Object|null*/ obj,
-						/*String*/ event,
-						/*Object|null*/ context,
-						/*String|Function*/ method,
-						/*Boolean?*/ dontFix){
-	// summary:
-	//		`dojo.connect` is the core event handling and delegation method in
-	//		Dojo. It allows one function to "listen in" on the execution of
-	//		any other, triggering the second whenever the first is called. Many
-	//		listeners may be attached to a function, and source functions may
-	//		be either regular function calls or DOM events.
-	//
-	// description:
-	//		Connects listeners to actions, so that after event fires, a
-	//		listener is called with the same arguments passed to the original
-	//		function.
-	//
-	//		Since `dojo.connect` allows the source of events to be either a
-	//		"regular" JavaScript function or a DOM event, it provides a uniform
-	//		interface for listening to all the types of events that an
-	//		application is likely to deal with though a single, unified
-	//		interface. DOM programmers may want to think of it as
-	//		"addEventListener for everything and anything".
-	//
-	//		When setting up a connection, the `event` parameter must be a
-	//		string that is the name of the method/event to be listened for. If
-	//		`obj` is null, `dojo.global` is assumed, meaning that connections
-	//		to global methods are supported but also that you may inadvertently
-	//		connect to a global by passing an incorrect object name or invalid
-	//		reference.
-	//
-	//		`dojo.connect` generally is forgiving. If you pass the name of a
-	//		function or method that does not yet exist on `obj`, connect will
-	//		not fail, but will instead set up a stub method. Similarly, null
-	//		arguments may simply be omitted such that fewer than 4 arguments
-	//		may be required to set up a connection See the examples for details.
-	//
-	//		The return value is a handle that is needed to
-	//		remove this connection with `dojo.disconnect`.
-	//
-	// obj:
-	//		The source object for the event function.
-	//		Defaults to `dojo.global` if null.
-	//		If obj is a DOM node, the connection is delegated
-	//		to the DOM event manager (unless dontFix is true).
-	//
-	// event:
-	//		String name of the event function in obj.
-	//		I.e. identifies a property `obj[event]`.
-	//
-	// context:
-	//		The object that method will receive as "this".
-	//
-	//		If context is null and method is a function, then method
-	//		inherits the context of event.
-	//
-	//		If method is a string then context must be the source
-	//		object object for method (context[method]). If context is null,
-	//		dojo.global is used.
-	//
-	// method:
-	//		A function reference, or name of a function in context.
-	//		The function identified by method fires after event does.
-	//		method receives the same arguments as the event.
-	//		See context argument comments for information on method's scope.
-	//
-	// dontFix:
-	//		If obj is a DOM node, set dontFix to true to prevent delegation
-	//		of this connection to the DOM event manager.
-	//
-	// example:
-	//		When obj.onchange(), do ui.update():
-	//	|	dojo.connect(obj, "onchange", ui, "update");
-	//	|	dojo.connect(obj, "onchange", ui, ui.update); // same
-	//
-	// example:
-	//		Using return value for disconnect:
-	//	|	var link = dojo.connect(obj, "onchange", ui, "update");
-	//	|	...
-	//	|	dojo.disconnect(link);
-	//
-	// example:
-	//		When onglobalevent executes, watcher.handler is invoked:
-	//	|	dojo.connect(null, "onglobalevent", watcher, "handler");
-	//
-	// example:
-	//		When ob.onCustomEvent executes, customEventHandler is invoked:
-	//	|	dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
-	//	|	dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
-	//
-	// example:
-	//		When ob.onCustomEvent executes, customEventHandler is invoked
-	//		with the same scope (this):
-	//	|	dojo.connect(ob, "onCustomEvent", null, customEventHandler);
-	//	|	dojo.connect(ob, "onCustomEvent", customEventHandler); // same
-	//
-	// example:
-	//		When globalEvent executes, globalHandler is invoked
-	//		with the same scope (this):
-	//	|	dojo.connect(null, "globalEvent", null, globalHandler);
-	//	|	dojo.connect("globalEvent", globalHandler); // same
-
-	// normalize arguments
-	var a=arguments, args=[], i=0;
-	// if a[0] is a String, obj was omitted
-	args.push(dojo.isString(a[0]) ? null : a[i++], a[i++]);
-	// if the arg-after-next is a String or Function, context was NOT omitted
-	var a1 = a[i+1];
-	args.push(dojo.isString(a1)||dojo.isFunction(a1) ? a[i++] : null, a[i++]);
-	// absorb any additional arguments
-	for(var l=a.length; i<l; i++){	args.push(a[i]); }
-	// do the actual work
-	return dojo._connect.apply(this, args); /*Handle*/
-}
-
-// used by non-browser hostenvs. always overriden by event.js
-dojo._connect = function(obj, event, context, method){
-	var l=dojo._listener, h=l.add(obj, event, dojo.hitch(context, method));
-	return [obj, event, h, l]; // Handle
-};
-
-dojo.disconnect = function(/*Handle*/ handle){
-	// summary:
-	//		Remove a link created by dojo.connect.
-	// description:
-	//		Removes the connection between event and the method referenced by handle.
-	// handle:
-	//		the return value of the dojo.connect call that created the connection.
-	if(handle && handle[0] !== undefined){
-		dojo._disconnect.apply(this, handle);
-		// let's not keep this reference
-		delete handle[0];
-	}
-};
-
-dojo._disconnect = function(obj, event, handle, listener){
-	listener.remove(obj, event, handle);
-};
-
-// topic publish/subscribe
-
-dojo._topics = {};
-
-dojo.subscribe = function(/*String*/ topic, /*Object|null*/ context, /*String|Function*/ method){
-	//	summary:
-	//		Attach a listener to a named topic. The listener function is invoked whenever the
-	//		named topic is published (see: dojo.publish).
-	//		Returns a handle which is needed to unsubscribe this listener.
-	//	context:
-	//		Scope in which method will be invoked, or null for default scope.
-	//	method:
-	//		The name of a function in context, or a function reference. This is the function that
-	//		is invoked when topic is published.
-	//	example:
-	//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); });
-	//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
-
-	// support for 2 argument invocation (omitting context) depends on hitch
-	return [topic, dojo._listener.add(dojo._topics, topic, dojo.hitch(context, method))]; /*Handle*/
-};
-
-dojo.unsubscribe = function(/*Handle*/ handle){
-	//	summary:
-	//	 	Remove a topic listener.
-	//	handle:
-	//	 	The handle returned from a call to subscribe.
-	//	example:
-	//	|	var alerter = dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
-	//	|	...
-	//	|	dojo.unsubscribe(alerter);
-	if(handle){
-		dojo._listener.remove(dojo._topics, handle[0], handle[1]);
-	}
-};
-
-dojo.publish = function(/*String*/ topic, /*Array*/ args){
-	//	summary:
-	//	 	Invoke all listener method subscribed to topic.
-	//	topic:
-	//	 	The name of the topic to publish.
-	//	args:
-	//	 	An array of arguments. The arguments will be applied
-	//	 	to each topic subscriber (as first class parameters, via apply).
-	//	example:
-	//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
-	//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
-
-	// Note that args is an array, which is more efficient vs variable length
-	// argument list.  Ideally, var args would be implemented via Array
-	// throughout the APIs.
-	var f = dojo._topics[topic];
-	if(f){
-		f.apply(this, args||[]);
-	}
-};
-
-dojo.connectPublisher = function(	/*String*/ topic,
-									/*Object|null*/ obj,
-									/*String*/ event){
-	//	summary:
-	//	 	Ensure that every time obj.event() is called, a message is published
-	//	 	on the topic. Returns a handle which can be passed to
-	//	 	dojo.disconnect() to disable subsequent automatic publication on
-	//	 	the topic.
-	//	topic:
-	//	 	The name of the topic to publish.
-	//	obj:
-	//	 	The source object for the event function. Defaults to dojo.global
-	//	 	if null.
-	//	event:
-	//	 	The name of the event function in obj.
-	//	 	I.e. identifies a property obj[event].
-	//	example:
-	//	|	dojo.connectPublisher("/ajax/start", dojo, "xhrGet");
-	var pf = function(){ dojo.publish(topic, arguments); }
-	return event ? dojo.connect(obj, event, pf) : dojo.connect(obj, pf); //Handle
-};
-
-}
+//>>built
+define("dojo/_base/connect",["./kernel","../on","../topic","../aspect","./event","../mouse","./sniff","./lang","../keys"],function(_1,on,_2,_3,_4,_5,_6,_7){_6.add("events-keypress-typed",function(){var _8={charCode:0};try{_8=document.createEvent("KeyboardEvent");(_8.initKeyboardEvent||_8.initKeyEvent).call(_8,"keypress",true,true,null,false,false,false,false,9,3);}catch(e){}return _8.charCode==0&&!_6("opera");});function _9(_a,_b,_c,_d,_e){_d=_7.hitch(_c,_d);if(!_a||!(_a.addEventListener||_a.attachEvent)){return _3.after(_a||_1.global,_b,_d,true);}if(typeof _b=="string"&&_b.substring(0,2)=="on"){_b=_b.substring(2);}if(!_a){_a=_1.global;}if(!_e){switch(_b){case "keypress":_b=_f;break;case "mouseenter":_b=_5.enter;break;case "mouseleave":_b=_5.leave;break;}}return on(_a,_b,_d,_e);};var _10={106:42,111:47,186:59,187:43,188:44,189:45,190:46,191:47,192:96,219:91,220:92,221:93,222:39,229:113};var _11=_6("mac")?"metaKey":"ctrlKey";var _12=function(evt,_13){var _14=_7.mixin({},evt,_13);_15(_14);_14.preventDefault=function(){evt.preventDefault();};_14.stopPropagation=function(){evt.stopPropagation();};return _14;};function _15(evt){evt.keyChar=evt.charCode?String.fromCharCode(evt.charCode):"";evt.charOrCode=evt.keyChar||evt.keyCode;};var _f;if(_6("events-keypress-typed")){var _16=function(e,_17){try{return (e.keyCode=_17);}catch(e){return 0;}};_f=function(_18,_19){var _1a=on(_18,"keydown",function(evt){var k=evt.keyCode;var _1b=(k!=13||(_6("ie")>=9&&!_6("quirks")))&&k!=32&&(k!=27||!_6("ie"))&&(k<48||k>90)&&(k<96||k>111)&&(k<186||k>192)&&(k<219||k>222)&&k!=229;if(_1b||evt.ctrlKey){var c=_1b?0:k;if(evt.ctrlKey){if(k==3||k==13){return _19.call(evt.currentTarget,evt);}else{if(c>95&&c<106){c-=48;}else{if((!evt.shiftKey)&&(c>=65&&c<=90)){c+=32;}else{c=_10[c]||c;}}}}var _1c=_12(evt,{type:"keypress",faux:true,charCode:c});_19.call(evt.currentTarget,_1c);if(_6("ie")){_16(evt,_1c.keyCode);}}});var _1d=on(_18,"keypress",function(evt){var c=evt.charCode;c=c>=32?c:0;evt=_12(evt,{charCode:c,faux:true});return _19.call(this,evt);});return {remove:function(){_1a.remove();_1d.remove();}};};}else{if(_6("opera")){_f=function(_1e,_1f){return on(_1e,"keypress",function(evt){var c=evt.which;if(c==3){c=99;}c=c<32&&!evt.shiftKey?0:c;if(evt.ctrlKey&&!evt.shiftKey&&c>=65&&c<=90){c+=32;}return _1f.call(this,_12(evt,{charCode:c}));});};}else{_f=function(_20,_21){return on(_20,"keypress",function(evt){_15(evt);return _21.call(this,evt);});};}}var _22={_keypress:_f,connect:function(obj,_23,_24,_25,_26){var a=arguments,_27=[],i=0;_27.push(typeof a[0]=="string"?null:a[i++],a[i++]);var a1=a[i+1];_27.push(typeof a1=="string"||typeof a1=="function"?a[i++]:null,a[i++]);for(var l=a.length;i<l;i++){_27.push(a[i]);}return _9.apply(this,_27);},disconnect:function(_28){if(_28){_28.remove();}},subscribe:function(_29,_2a,_2b){return _2.subscribe(_29,_7.hitch(_2a,_2b));},publish:function(_2c,_2d){return _2.publish.apply(_2,[_2c].concat(_2d));},connectPublisher:function(_2e,obj,_2f){var pf=function(){_22.publish(_2e,arguments);};return _2f?_22.connect(obj,_2f,pf):_22.connect(obj,pf);},isCopyKey:function(e){return e[_11];}};_22.unsubscribe=_22.disconnect;1&&_7.mixin(_1,_22);return _22;});
\ No newline at end of file
diff --git a/lib/dojo/_base/connect.js.uncompressed.js b/lib/dojo/_base/connect.js.uncompressed.js
new file mode 100644
index 000000000..69de83e70
--- /dev/null
+++ b/lib/dojo/_base/connect.js.uncompressed.js
@@ -0,0 +1,400 @@
+define("dojo/_base/connect", ["./kernel", "../on", "../topic", "../aspect", "./event", "../mouse", "./sniff", "./lang", "../keys"], function(kernel, on, hub, aspect, eventModule, mouse, has, lang){
+//  module:
+//    dojo/_base/connect
+//  summary:
+//    This module defines the dojo.connect API.
+//		This modules also provides keyboard event handling helpers.
+//		This module exports an extension event for emulating Firefox's keypress handling.
+//		However, this extension event exists primarily for backwards compatibility and
+//		is not recommended. WebKit and IE uses an alternate keypress handling (only
+//		firing for printable characters, to distinguish from keydown events), and most
+//		consider the WebKit/IE behavior more desirable.
+has.add("events-keypress-typed", function(){ // keypresses should only occur a printable character is hit
+	var testKeyEvent = {charCode: 0};
+	try{
+		testKeyEvent = document.createEvent("KeyboardEvent");
+		(testKeyEvent.initKeyboardEvent || testKeyEvent.initKeyEvent).call(testKeyEvent, "keypress", true, true, null, false, false, false, false, 9, 3);
+	}catch(e){}
+	return testKeyEvent.charCode == 0 && !has("opera");
+});
+
+function connect_(obj, event, context, method, dontFix){
+	method = lang.hitch(context, method);
+	if(!obj || !(obj.addEventListener || obj.attachEvent)){
+		// it is a not a DOM node and we are using the dojo.connect style of treating a
+		// method like an event, must go right to aspect
+		return aspect.after(obj || kernel.global, event, method, true);
+	}
+	if(typeof event == "string" && event.substring(0, 2) == "on"){
+		event = event.substring(2);
+	}
+	if(!obj){
+		obj = kernel.global;
+	}
+	if(!dontFix){
+		switch(event){
+			// dojo.connect has special handling for these event types
+			case "keypress":
+				event = keypress;
+				break;
+			case "mouseenter":
+				event = mouse.enter;
+				break;
+			case "mouseleave":
+				event = mouse.leave;
+				break;
+		}
+	}
+	return on(obj, event, method, dontFix);
+}
+
+var _punctMap = {
+	106:42,
+	111:47,
+	186:59,
+	187:43,
+	188:44,
+	189:45,
+	190:46,
+	191:47,
+	192:96,
+	219:91,
+	220:92,
+	221:93,
+	222:39,
+	229:113
+};
+var evtCopyKey = has("mac") ? "metaKey" : "ctrlKey";
+
+
+var _synthesizeEvent = function(evt, props){
+	var faux = lang.mixin({}, evt, props);
+	setKeyChar(faux);
+	// FIXME: would prefer to use lang.hitch: lang.hitch(evt, evt.preventDefault);
+	// but it throws an error when preventDefault is invoked on Safari
+	// does Event.preventDefault not support "apply" on Safari?
+	faux.preventDefault = function(){ evt.preventDefault(); };
+	faux.stopPropagation = function(){ evt.stopPropagation(); };
+	return faux;
+};
+function setKeyChar(evt){
+	evt.keyChar = evt.charCode ? String.fromCharCode(evt.charCode) : '';
+	evt.charOrCode = evt.keyChar || evt.keyCode;
+}
+var keypress;
+if(has("events-keypress-typed")){
+	// this emulates Firefox's keypress behavior where every keydown can correspond to a keypress
+	var _trySetKeyCode = function(e, code){
+		try{
+			// squelch errors when keyCode is read-only
+			// (e.g. if keyCode is ctrl or shift)
+			return (e.keyCode = code);
+		}catch(e){
+			return 0;
+		}
+	};
+	keypress = function(object, listener){
+		var keydownSignal = on(object, "keydown", function(evt){
+			// munge key/charCode
+			var k=evt.keyCode;
+			// These are Windows Virtual Key Codes
+			// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/WinUI/WindowsUserInterface/UserInput/VirtualKeyCodes.asp
+			var unprintable = (k!=13 || (has("ie") >= 9 && !has("quirks"))) && k!=32 && (k!=27||!has("ie")) && (k<48||k>90) && (k<96||k>111) && (k<186||k>192) && (k<219||k>222) && k!=229;
+			// synthesize keypress for most unprintables and CTRL-keys
+			if(unprintable||evt.ctrlKey){
+				var c = unprintable ? 0 : k;
+				if(evt.ctrlKey){
+					if(k==3 || k==13){
+						return listener.call(evt.currentTarget, evt); // IE will post CTRL-BREAK, CTRL-ENTER as keypress natively
+					}else if(c>95 && c<106){
+						c -= 48; // map CTRL-[numpad 0-9] to ASCII
+					}else if((!evt.shiftKey)&&(c>=65&&c<=90)){
+						c += 32; // map CTRL-[A-Z] to lowercase
+					}else{
+						c = _punctMap[c] || c; // map other problematic CTRL combinations to ASCII
+					}
+				}
+				// simulate a keypress event
+				var faux = _synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c});
+				listener.call(evt.currentTarget, faux);
+				if(has("ie")){
+					_trySetKeyCode(evt, faux.keyCode);
+				}
+			}
+		});
+		var keypressSignal = on(object, "keypress", function(evt){
+			var c = evt.charCode;
+			c = c>=32 ? c : 0;
+			evt = _synthesizeEvent(evt, {charCode: c, faux: true});
+			return listener.call(this, evt);
+		});
+		return {
+			remove: function(){
+				keydownSignal.remove();
+				keypressSignal.remove();
+			}
+		};
+	};
+}else{
+	if(has("opera")){
+		keypress = function(object, listener){
+			return on(object, "keypress", function(evt){
+				var c = evt.which;
+				if(c==3){
+					c=99; // Mozilla maps CTRL-BREAK to CTRL-c
+				}
+				// can't trap some keys at all, like INSERT and DELETE
+				// there is no differentiating info between DELETE and ".", or INSERT and "-"
+				c = c<32 && !evt.shiftKey ? 0 : c;
+				if(evt.ctrlKey && !evt.shiftKey && c>=65 && c<=90){
+					// lowercase CTRL-[A-Z] keys
+					c += 32;
+				}
+				return listener.call(this, _synthesizeEvent(evt, { charCode: c }));
+			});
+		};
+	}else{
+		keypress = function(object, listener){
+			return on(object, "keypress", function(evt){
+				setKeyChar(evt);
+				return listener.call(this, evt);
+			});
+		};
+	}
+}
+
+var connect = {
+	_keypress:keypress,
+
+	connect:function(obj, event, context, method, dontFix){
+		// normalize arguments
+		var a=arguments, args=[], i=0;
+		// if a[0] is a String, obj was omitted
+		args.push(typeof a[0] == "string" ? null : a[i++], a[i++]);
+		// if the arg-after-next is a String or Function, context was NOT omitted
+		var a1 = a[i+1];
+		args.push(typeof a1 == "string" || typeof a1 == "function" ? a[i++] : null, a[i++]);
+		// absorb any additional arguments
+		for(var l=a.length; i<l; i++){	args.push(a[i]); }
+		return connect_.apply(this, args);
+	},
+
+	disconnect:function(handle){
+		if(handle){
+			handle.remove();
+		}
+	},
+
+	subscribe:function(topic, context, method){
+		return hub.subscribe(topic, lang.hitch(context, method));
+	},
+
+	publish:function(topic, args){
+		return hub.publish.apply(hub, [topic].concat(args));
+	},
+
+	connectPublisher:function(topic, obj, event){
+		var pf = function(){ connect.publish(topic, arguments); };
+		return event ? connect.connect(obj, event, pf) : connect.connect(obj, pf); //Handle
+	},
+
+	isCopyKey: function(e){
+		return e[evtCopyKey];	// Boolean
+	}
+};
+connect.unsubscribe = connect.disconnect;
+
+1 && lang.mixin(kernel, connect);
+return connect;
+
+/*=====
+dojo.connect = function(obj, event, context, method, dontFix){
+	// summary:
+	//		`dojo.connect` is the core event handling and delegation method in
+	//		Dojo. It allows one function to "listen in" on the execution of
+	//		any other, triggering the second whenever the first is called. Many
+	//		listeners may be attached to a function, and source functions may
+	//		be either regular function calls or DOM events.
+	//
+	// description:
+	//		Connects listeners to actions, so that after event fires, a
+	//		listener is called with the same arguments passed to the original
+	//		function.
+	//
+	//		Since `dojo.connect` allows the source of events to be either a
+	//		"regular" JavaScript function or a DOM event, it provides a uniform
+	//		interface for listening to all the types of events that an
+	//		application is likely to deal with though a single, unified
+	//		interface. DOM programmers may want to think of it as
+	//		"addEventListener for everything and anything".
+	//
+	//		When setting up a connection, the `event` parameter must be a
+	//		string that is the name of the method/event to be listened for. If
+	//		`obj` is null, `kernel.global` is assumed, meaning that connections
+	//		to global methods are supported but also that you may inadvertently
+	//		connect to a global by passing an incorrect object name or invalid
+	//		reference.
+	//
+	//		`dojo.connect` generally is forgiving. If you pass the name of a
+	//		function or method that does not yet exist on `obj`, connect will
+	//		not fail, but will instead set up a stub method. Similarly, null
+	//		arguments may simply be omitted such that fewer than 4 arguments
+	//		may be required to set up a connection See the examples for details.
+	//
+	//		The return value is a handle that is needed to
+	//		remove this connection with `dojo.disconnect`.
+	//
+	// obj: Object|null:
+	//		The source object for the event function.
+	//		Defaults to `kernel.global` if null.
+	//		If obj is a DOM node, the connection is delegated
+	//		to the DOM event manager (unless dontFix is true).
+	//
+	// event: String:
+	//		String name of the event function in obj.
+	//		I.e. identifies a property `obj[event]`.
+	//
+	// context: Object|null
+	//		The object that method will receive as "this".
+	//
+	//		If context is null and method is a function, then method
+	//		inherits the context of event.
+	//
+	//		If method is a string then context must be the source
+	//		object object for method (context[method]). If context is null,
+	//		kernel.global is used.
+	//
+	// method: String|Function:
+	//		A function reference, or name of a function in context.
+	//		The function identified by method fires after event does.
+	//		method receives the same arguments as the event.
+	//		See context argument comments for information on method's scope.
+	//
+	// dontFix: Boolean?
+	//		If obj is a DOM node, set dontFix to true to prevent delegation
+	//		of this connection to the DOM event manager.
+	//
+	// example:
+	//		When obj.onchange(), do ui.update():
+	//	|	dojo.connect(obj, "onchange", ui, "update");
+	//	|	dojo.connect(obj, "onchange", ui, ui.update); // same
+	//
+	// example:
+	//		Using return value for disconnect:
+	//	|	var link = dojo.connect(obj, "onchange", ui, "update");
+	//	|	...
+	//	|	dojo.disconnect(link);
+	//
+	// example:
+	//		When onglobalevent executes, watcher.handler is invoked:
+	//	|	dojo.connect(null, "onglobalevent", watcher, "handler");
+	//
+	// example:
+	//		When ob.onCustomEvent executes, customEventHandler is invoked:
+	//	|	dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
+	//	|	dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
+	//
+	// example:
+	//		When ob.onCustomEvent executes, customEventHandler is invoked
+	//		with the same scope (this):
+	//	|	dojo.connect(ob, "onCustomEvent", null, customEventHandler);
+	//	|	dojo.connect(ob, "onCustomEvent", customEventHandler); // same
+	//
+	// example:
+	//		When globalEvent executes, globalHandler is invoked
+	//		with the same scope (this):
+	//	|	dojo.connect(null, "globalEvent", null, globalHandler);
+	//	|	dojo.connect("globalEvent", globalHandler); // same
+}
+=====*/
+
+/*=====
+dojo.disconnect = function(handle){
+	// summary:
+	//		Remove a link created by dojo.connect.
+	// description:
+	//		Removes the connection between event and the method referenced by handle.
+	// handle: Handle:
+	//		the return value of the dojo.connect call that created the connection.
+}
+=====*/
+
+/*=====
+dojo.subscribe = function(topic, context, method){
+	//	summary:
+	//		Attach a listener to a named topic. The listener function is invoked whenever the
+	//		named topic is published (see: dojo.publish).
+	//		Returns a handle which is needed to unsubscribe this listener.
+	//	topic: String:
+	//		The topic to which to subscribe.
+	//	context: Object|null:
+	//		Scope in which method will be invoked, or null for default scope.
+	//	method: String|Function:
+	//		The name of a function in context, or a function reference. This is the function that
+	//		is invoked when topic is published.
+	//	example:
+	//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); });
+	//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
+}
+=====*/
+
+/*=====
+dojo.unsubscribe = function(handle){
+	//	summary:
+	//		Remove a topic listener.
+	//	handle: Handle
+	//		The handle returned from a call to subscribe.
+	//	example:
+	//	|	var alerter = dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+	//	|	...
+	//	|	dojo.unsubscribe(alerter);
+}
+=====*/
+
+/*=====
+dojo.publish = function(topic, args){
+	//	summary:
+	//		Invoke all listener method subscribed to topic.
+	//	topic: String:
+	//		The name of the topic to publish.
+	//	args: Array?
+	//		An array of arguments. The arguments will be applied
+	//		to each topic subscriber (as first class parameters, via apply).
+	//	example:
+	//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+	//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
+}
+=====*/
+
+/*=====
+dojo.connectPublisher = function(topic, obj, event){
+	//	summary:
+	//		Ensure that every time obj.event() is called, a message is published
+	//		on the topic. Returns a handle which can be passed to
+	//		dojo.disconnect() to disable subsequent automatic publication on
+	//		the topic.
+	//	topic: String:
+	//		The name of the topic to publish.
+	//	obj: Object|null:
+	//		The source object for the event function. Defaults to kernel.global
+	//		if null.
+	//	event: String:
+	//		The name of the event function in obj.
+	//		I.e. identifies a property obj[event].
+	//	example:
+	//	|	dojo.connectPublisher("/ajax/start", dojo, "xhrGet");
+}
+=====*/
+
+/*=====
+dojo.isCopyKey = function(e){
+	// summary:
+	//		Checks an event for the copy key (meta on Mac, and ctrl anywhere else)
+	// e: Event
+	//		Event object to examine
+}
+=====*/
+
+});
+
+
diff --git a/lib/dojo/_base/declare.js b/lib/dojo/_base/declare.js
index 437914870..9247fcc42 100644
--- a/lib/dojo/_base/declare.js
+++ b/lib/dojo/_base/declare.js
@@ -4,1045 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.declare"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.declare"] = true;
-dojo.provide("dojo._base.declare");
-dojo.require("dojo._base.lang");
-dojo.require("dojo._base.array");
-
-
-(function(){
-	var d = dojo, mix = d._mixin, op = Object.prototype, opts = op.toString,
-		xtor = new Function, counter = 0, cname = "constructor";
-
-	function err(msg, cls){ throw new Error("declare" + (cls ? " " + cls : "") + ": " + msg); }
-
-	// C3 Method Resolution Order (see http://www.python.org/download/releases/2.3/mro/)
-	function c3mro(bases, className){
-		var result = [], roots = [{cls: 0, refs: []}], nameMap = {}, clsCount = 1,
-			l = bases.length, i = 0, j, lin, base, top, proto, rec, name, refs;
-
-		// build a list of bases naming them if needed
-		for(; i < l; ++i){
-			base = bases[i];
-			if(!base){
-				err("mixin #" + i + " is unknown. Did you use dojo.require to pull it in?", className);
-			}else if(opts.call(base) != "[object Function]"){
-				err("mixin #" + i + " is not a callable constructor.", className);
-			}
-			lin = base._meta ? base._meta.bases : [base];
-			top = 0;
-			// add bases to the name map
-			for(j = lin.length - 1; j >= 0; --j){
-				proto = lin[j].prototype;
-				if(!proto.hasOwnProperty("declaredClass")){
-					proto.declaredClass = "uniqName_" + (counter++);
-				}
-				name = proto.declaredClass;
-				if(!nameMap.hasOwnProperty(name)){
-					nameMap[name] = {count: 0, refs: [], cls: lin[j]};
-					++clsCount;
-				}
-				rec = nameMap[name];
-				if(top && top !== rec){
-					rec.refs.push(top);
-					++top.count;
-				}
-				top = rec;
-			}
-			++top.count;
-			roots[0].refs.push(top);
-		}
-
-		// remove classes without external references recursively
-		while(roots.length){
-			top = roots.pop();
-			result.push(top.cls);
-			--clsCount;
-			// optimization: follow a single-linked chain
-			while(refs = top.refs, refs.length == 1){
-				top = refs[0];
-				if(!top || --top.count){
-					// branch or end of chain => do not end to roots
-					top = 0;
-					break;
-				}
-				result.push(top.cls);
-				--clsCount;
-			}
-			if(top){
-				// branch
-				for(i = 0, l = refs.length; i < l; ++i){
-					top = refs[i];
-					if(!--top.count){
-						roots.push(top);
-					}
-				}
-			}
-		}
-		if(clsCount){
-			err("can't build consistent linearization", className);
-		}
-
-		// calculate the superclass offset
-		base = bases[0];
-		result[0] = base ?
-			base._meta && base === result[result.length - base._meta.bases.length] ?
-				base._meta.bases.length : 1 : 0;
-
-		return result;
-	}
-
-	function inherited(args, a, f){
-		var name, chains, bases, caller, meta, base, proto, opf, pos,
-			cache = this._inherited = this._inherited || {};
-
-		// crack arguments
-		if(typeof args == "string"){
-			name = args;
-			args = a;
-			a = f;
-		}
-		f = 0;
-
-		caller = args.callee;
-		name = name || caller.nom;
-		if(!name){
-			err("can't deduce a name to call inherited()", this.declaredClass);
-		}
-
-		meta = this.constructor._meta;
-		bases = meta.bases;
-
-		pos = cache.p;
-		if(name != cname){
-			// method
-			if(cache.c !== caller){
-				// cache bust
-				pos = 0;
-				base = bases[0];
-				meta = base._meta;
-				if(meta.hidden[name] !== caller){
-					// error detection
-					chains = meta.chains;
-					if(chains && typeof chains[name] == "string"){
-						err("calling chained method with inherited: " + name, this.declaredClass);
-					}
-					// find caller
-					do{
-						meta = base._meta;
-						proto = base.prototype;
-						if(meta && (proto[name] === caller && proto.hasOwnProperty(name) || meta.hidden[name] === caller)){
-							break;
-						}
-					}while(base = bases[++pos]); // intentional assignment
-					pos = base ? pos : -1;
-				}
-			}
-			// find next
-			base = bases[++pos];
-			if(base){
-				proto = base.prototype;
-				if(base._meta && proto.hasOwnProperty(name)){
-					f = proto[name];
-				}else{
-					opf = op[name];
-					do{
-						proto = base.prototype;
-						f = proto[name];
-						if(f && (base._meta ? proto.hasOwnProperty(name) : f !== opf)){
-							break;
-						}
-					}while(base = bases[++pos]); // intentional assignment
-				}
-			}
-			f = base && f || op[name];
-		}else{
-			// constructor
-			if(cache.c !== caller){
-				// cache bust
-				pos = 0;
-				meta = bases[0]._meta;
-				if(meta && meta.ctor !== caller){
-					// error detection
-					chains = meta.chains;
-					if(!chains || chains.constructor !== "manual"){
-						err("calling chained constructor with inherited", this.declaredClass);
-					}
-					// find caller
-					while(base = bases[++pos]){ // intentional assignment
-						meta = base._meta;
-						if(meta && meta.ctor === caller){
-							break;
-						}
-					}
-					pos = base ? pos : -1;
-				}
-			}
-			// find next
-			while(base = bases[++pos]){	// intentional assignment
-				meta = base._meta;
-				f = meta ? meta.ctor : base;
-				if(f){
-					break;
-				}
-			}
-			f = base && f;
-		}
-
-		// cache the found super method
-		cache.c = f;
-		cache.p = pos;
-
-		// now we have the result
-		if(f){
-			return a === true ? f : f.apply(this, a || args);
-		}
-		// intentionally if a super method was not found
-	}
-
-	function getInherited(name, args){
-		if(typeof name == "string"){
-			return this.inherited(name, args, true);
-		}
-		return this.inherited(name, true);
-	}
-
-	// emulation of "instanceof"
-	function isInstanceOf(cls){
-		var bases = this.constructor._meta.bases;
-		for(var i = 0, l = bases.length; i < l; ++i){
-			if(bases[i] === cls){
-				return true;
-			}
-		}
-		return this instanceof cls;
-	}
-
-	function mixOwn(target, source){
-		var name, i = 0, l = d._extraNames.length;
-		// add props adding metadata for incoming functions skipping a constructor
-		for(name in source){
-			if(name != cname && source.hasOwnProperty(name)){
-				target[name] = source[name];
-			}
-		}
-		// process unenumerable methods on IE
-		for(; i < l; ++i){
-			name = d._extraNames[i];
-			if(name != cname && source.hasOwnProperty(name)){
-				target[name] = source[name];
-			}
-		}
-	}
-
-	// implementation of safe mixin function
-	function safeMixin(target, source){
-		var name, t, i = 0, l = d._extraNames.length;
-		// add props adding metadata for incoming functions skipping a constructor
-		for(name in source){
-			t = source[name];
-			if((t !== op[name] || !(name in op)) && name != cname){
-				if(opts.call(t) == "[object Function]"){
-					// non-trivial function method => attach its name
-					t.nom = name;
-				}
-				target[name] = t;
-			}
-		}
-		// process unenumerable methods on IE
-		for(; i < l; ++i){
-			name = d._extraNames[i];
-			t = source[name];
-			if((t !== op[name] || !(name in op)) && name != cname){
-				if(opts.call(t) == "[object Function]"){
-					// non-trivial function method => attach its name
-					t.nom = name;
-				}
-				target[name] = t;
-			}
-		}
-		return target;
-	}
-
-	function extend(source){
-		safeMixin(this.prototype, source);
-		return this;
-	}
-
-	// chained constructor compatible with the legacy dojo.declare()
-	function chainedConstructor(bases, ctorSpecial){
-		return function(){
-			var a = arguments, args = a, a0 = a[0], f, i, m,
-				l = bases.length, preArgs;
-
-			if(!(this instanceof a.callee)){
-				// not called via new, so force it
-				return applyNew(a);
-			}
-
-			//this._inherited = {};
-			// perform the shaman's rituals of the original dojo.declare()
-			// 1) call two types of the preamble
-			if(ctorSpecial && (a0 && a0.preamble || this.preamble)){
-				// full blown ritual
-				preArgs = new Array(bases.length);
-				// prepare parameters
-				preArgs[0] = a;
-				for(i = 0;;){
-					// process the preamble of the 1st argument
-					a0 = a[0];
-					if(a0){
-						f = a0.preamble;
-						if(f){
-							a = f.apply(this, a) || a;
-						}
-					}
-					// process the preamble of this class
-					f = bases[i].prototype;
-					f = f.hasOwnProperty("preamble") && f.preamble;
-					if(f){
-						a = f.apply(this, a) || a;
-					}
-					// one peculiarity of the preamble:
-					// it is called if it is not needed,
-					// e.g., there is no constructor to call
-					// let's watch for the last constructor
-					// (see ticket #9795)
-					if(++i == l){
-						break;
-					}
-					preArgs[i] = a;
-				}
-			}
-			// 2) call all non-trivial constructors using prepared arguments
-			for(i = l - 1; i >= 0; --i){
-				f = bases[i];
-				m = f._meta;
-				f = m ? m.ctor : f;
-				if(f){
-					f.apply(this, preArgs ? preArgs[i] : a);
-				}
-			}
-			// 3) continue the original ritual: call the postscript
-			f = this.postscript;
-			if(f){
-				f.apply(this, args);
-			}
-		};
-	}
-
-
-	// chained constructor compatible with the legacy dojo.declare()
-	function singleConstructor(ctor, ctorSpecial){
-		return function(){
-			var a = arguments, t = a, a0 = a[0], f;
-
-			if(!(this instanceof a.callee)){
-				// not called via new, so force it
-				return applyNew(a);
-			}
-
-			//this._inherited = {};
-			// perform the shaman's rituals of the original dojo.declare()
-			// 1) call two types of the preamble
-			if(ctorSpecial){
-				// full blown ritual
-				if(a0){
-					// process the preamble of the 1st argument
-					f = a0.preamble;
-					if(f){
-						t = f.apply(this, t) || t;
-					}
-				}
-				f = this.preamble;
-				if(f){
-					// process the preamble of this class
-					f.apply(this, t);
-					// one peculiarity of the preamble:
-					// it is called even if it is not needed,
-					// e.g., there is no constructor to call
-					// let's watch for the last constructor
-					// (see ticket #9795)
-				}
-			}
-			// 2) call a constructor
-			if(ctor){
-				ctor.apply(this, a);
-			}
-			// 3) continue the original ritual: call the postscript
-			f = this.postscript;
-			if(f){
-				f.apply(this, a);
-			}
-		};
-	}
-
-	// plain vanilla constructor (can use inherited() to call its base constructor)
-	function simpleConstructor(bases){
-		return function(){
-			var a = arguments, i = 0, f, m;
-
-			if(!(this instanceof a.callee)){
-				// not called via new, so force it
-				return applyNew(a);
-			}
-
-			//this._inherited = {};
-			// perform the shaman's rituals of the original dojo.declare()
-			// 1) do not call the preamble
-			// 2) call the top constructor (it can use this.inherited())
-			for(; f = bases[i]; ++i){ // intentional assignment
-				m = f._meta;
-				f = m ? m.ctor : f;
-				if(f){
-					f.apply(this, a);
-					break;
-				}
-			}
-			// 3) call the postscript
-			f = this.postscript;
-			if(f){
-				f.apply(this, a);
-			}
-		};
-	}
-
-	function chain(name, bases, reversed){
-		return function(){
-			var b, m, f, i = 0, step = 1;
-			if(reversed){
-				i = bases.length - 1;
-				step = -1;
-			}
-			for(; b = bases[i]; i += step){ // intentional assignment
-				m = b._meta;
-				f = (m ? m.hidden : b.prototype)[name];
-				if(f){
-					f.apply(this, arguments);
-				}
-			}
-		};
-	}
-
-	// forceNew(ctor)
-	// return a new object that inherits from ctor.prototype but
-	// without actually running ctor on the object.
-	function forceNew(ctor){
-		// create object with correct prototype using a do-nothing
-		// constructor
-		xtor.prototype = ctor.prototype;
-		var t = new xtor;
-		xtor.prototype = null;	// clean up
-		return t;
-	}
-
-	// applyNew(args)
-	// just like 'new ctor()' except that the constructor and its arguments come
-	// from args, which must be an array or an arguments object
-	function applyNew(args){
-		// create an object with ctor's prototype but without
-		// calling ctor on it.
-		var ctor = args.callee, t = forceNew(ctor);
-		// execute the real constructor on the new object
-		ctor.apply(t, args);
-		return t;
-	}
-
-	d.declare = function(className, superclass, props){
-		// crack parameters
-		if(typeof className != "string"){
-			props = superclass;
-			superclass = className;
-			className = "";
-		}
-		props = props || {};
-
-		var proto, i, t, ctor, name, bases, chains, mixins = 1, parents = superclass;
-
-		// build a prototype
-		if(opts.call(superclass) == "[object Array]"){
-			// C3 MRO
-			bases = c3mro(superclass, className);
-			t = bases[0];
-			mixins = bases.length - t;
-			superclass = bases[mixins];
-		}else{
-			bases = [0];
-			if(superclass){
-				if(opts.call(superclass) == "[object Function]"){
-					t = superclass._meta;
-					bases = bases.concat(t ? t.bases : superclass);
-				}else{
-					err("base class is not a callable constructor.", className);
-				}
-			}else if(superclass !== null){
-				err("unknown base class. Did you use dojo.require to pull it in?", className);
-			}
-		}
-		if(superclass){
-			for(i = mixins - 1;; --i){
-				proto = forceNew(superclass);
-				if(!i){
-					// stop if nothing to add (the last base)
-					break;
-				}
-				// mix in properties
-				t = bases[i];
-				(t._meta ? mixOwn : mix)(proto, t.prototype);
-				// chain in new constructor
-				ctor = new Function;
-				ctor.superclass = superclass;
-				ctor.prototype = proto;
-				superclass = proto.constructor = ctor;
-			}
-		}else{
-			proto = {};
-		}
-		// add all properties
-		safeMixin(proto, props);
-		// add constructor
-		t = props.constructor;
-		if(t !== op.constructor){
-			t.nom = cname;
-			proto.constructor = t;
-		}
-
-		// collect chains and flags
-		for(i = mixins - 1; i; --i){ // intentional assignment
-			t = bases[i]._meta;
-			if(t && t.chains){
-				chains = mix(chains || {}, t.chains);
-			}
-		}
-		if(proto["-chains-"]){
-			chains = mix(chains || {}, proto["-chains-"]);
-		}
-
-		// build ctor
-		t = !chains || !chains.hasOwnProperty(cname);
-		bases[0] = ctor = (chains && chains.constructor === "manual") ? simpleConstructor(bases) :
-			(bases.length == 1 ? singleConstructor(props.constructor, t) : chainedConstructor(bases, t));
-
-		// add meta information to the constructor
-		ctor._meta  = {bases: bases, hidden: props, chains: chains,
-			parents: parents, ctor: props.constructor};
-		ctor.superclass = superclass && superclass.prototype;
-		ctor.extend = extend;
-		ctor.prototype = proto;
-		proto.constructor = ctor;
-
-		// add "standard" methods to the prototype
-		proto.getInherited = getInherited;
-		proto.inherited = inherited;
-		proto.isInstanceOf = isInstanceOf;
-
-		// add name if specified
-		if(className){
-			proto.declaredClass = className;
-			d.setObject(className, ctor);
-		}
-
-		// build chains and add them to the prototype
-		if(chains){
-			for(name in chains){
-				if(proto[name] && typeof chains[name] == "string" && name != cname){
-					t = proto[name] = chain(name, bases, chains[name] === "after");
-					t.nom = name;
-				}
-			}
-		}
-		// chained methods do not return values
-		// no need to chain "invisible" functions
-
-		return ctor;	// Function
-	};
-
-	d.safeMixin = safeMixin;
-
-	/*=====
-	dojo.declare = function(className, superclass, props){
-		//	summary:
-		//		Create a feature-rich constructor from compact notation.
-		//	className: String?:
-		//		The optional name of the constructor (loosely, a "class")
-		//		stored in the "declaredClass" property in the created prototype.
-		//		It will be used as a global name for a created constructor.
-		//	superclass: Function|Function[]:
-		//		May be null, a Function, or an Array of Functions. This argument
-		//		specifies a list of bases (the left-most one is the most deepest
-		//		base).
-		//	props: Object:
-		//		An object whose properties are copied to the created prototype.
-		//		Add an instance-initialization function by making it a property
-		//		named "constructor".
-		//	returns:
-		//		New constructor function.
-		//	description:
-		//		Create a constructor using a compact notation for inheritance and
-		//		prototype extension.
-		//
-		//		Mixin ancestors provide a type of multiple inheritance.
-		//		Prototypes of mixin ancestors are copied to the new class:
-		//		changes to mixin prototypes will not affect classes to which
-		//		they have been mixed in.
-		//
-		//		Ancestors can be compound classes created by this version of
-		//		dojo.declare. In complex cases all base classes are going to be
-		//		linearized according to C3 MRO algorithm
-		//		(see http://www.python.org/download/releases/2.3/mro/ for more
-		//		details).
-		//
-		//		"className" is cached in "declaredClass" property of the new class,
-		//		if it was supplied. The immediate super class will be cached in
-		//		"superclass" property of the new class.
-		//
-		//		Methods in "props" will be copied and modified: "nom" property
-		//		(the declared name of the method) will be added to all copied
-		//		functions to help identify them for the internal machinery. Be
-		//		very careful, while reusing methods: if you use the same
-		//		function under different names, it can produce errors in some
-		//		cases.
-		//
-		//		It is possible to use constructors created "manually" (without
-		//		dojo.declare) as bases. They will be called as usual during the
-		//		creation of an instance, their methods will be chained, and even
-		//		called by "this.inherited()".
-		//
-		//		Special property "-chains-" governs how to chain methods. It is
-		//		a dictionary, which uses method names as keys, and hint strings
-		//		as values. If a hint string is "after", this method will be
-		//		called after methods of its base classes. If a hint string is
-		//		"before", this method will be called before methods of its base
-		//		classes.
-		//
-		//		If "constructor" is not mentioned in "-chains-" property, it will
-		//		be chained using the legacy mode: using "after" chaining,
-		//		calling preamble() method before each constructor, if available,
-		//		and calling postscript() after all constructors were executed.
-		//		If the hint is "after", it is chained as a regular method, but
-		//		postscript() will be called after the chain of constructors.
-		//		"constructor" cannot be chained "before", but it allows
-		//		a special hint string: "manual", which means that constructors
-		//		are not going to be chained in any way, and programmer will call
-		//		them manually using this.inherited(). In the latter case
-		//		postscript() will be called after the construction.
-		//
-		//		All chaining hints are "inherited" from base classes and
-		//		potentially can be overridden. Be very careful when overriding
-		//		hints! Make sure that all chained methods can work in a proposed
-		//		manner of chaining.
-		//
-		//		Once a method was chained, it is impossible to unchain it. The
-		//		only exception is "constructor". You don't need to define a
-		//		method in order to supply a chaining hint.
-		//
-		//		If a method is chained, it cannot use this.inherited() because
-		//		all other methods in the hierarchy will be called automatically.
-		//
-		//		Usually constructors and initializers of any kind are chained
-		//		using "after" and destructors of any kind are chained as
-		//		"before". Note that chaining assumes that chained methods do not
-		//		return any value: any returned value will be discarded.
-		//
-		//	example:
-		//	|	dojo.declare("my.classes.bar", my.classes.foo, {
-		//	|		// properties to be added to the class prototype
-		//	|		someValue: 2,
-		//	|		// initialization function
-		//	|		constructor: function(){
-		//	|			this.myComplicatedObject = new ReallyComplicatedObject();
-		//	|		},
-		//	|		// other functions
-		//	|		someMethod: function(){
-		//	|			doStuff();
-		//	|		}
-		//	|	});
-		//
-		//	example:
-		//	|	var MyBase = dojo.declare(null, {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//	|	var MyClass1 = dojo.declare(MyBase, {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//	|	var MyClass2 = dojo.declare(MyBase, {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//	|	var MyDiamond = dojo.declare([MyClass1, MyClass2], {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//
-		//	example:
-		//	|	var F = function(){ console.log("raw constructor"); };
-		//	|	F.prototype.method = function(){
-		//	|		console.log("raw method");
-		//	|	};
-		//	|	var A = dojo.declare(F, {
-		//	|		constructor: function(){
-		//	|			console.log("A.constructor");
-		//	|		},
-		//	|		method: function(){
-		//	|			console.log("before calling F.method...");
-		//	|			this.inherited(arguments);
-		//	|			console.log("...back in A");
-		//	|		}
-		//	|	});
-		//	|	new A().method();
-		//	|	// will print:
-		//	|	// raw constructor
-		//	|	// A.constructor
-		//	|	// before calling F.method...
-		//	|	// raw method
-		//	|	// ...back in A
-		//
-		//	example:
-		//	|	var A = dojo.declare(null, {
-		//	|		"-chains-": {
-		//	|			destroy: "before"
-		//	|		}
-		//	|	});
-		//	|	var B = dojo.declare(A, {
-		//	|		constructor: function(){
-		//	|			console.log("B.constructor");
-		//	|		},
-		//	|		destroy: function(){
-		//	|			console.log("B.destroy");
-		//	|		}
-		//	|	});
-		//	|	var C = dojo.declare(B, {
-		//	|		constructor: function(){
-		//	|			console.log("C.constructor");
-		//	|		},
-		//	|		destroy: function(){
-		//	|			console.log("C.destroy");
-		//	|		}
-		//	|	});
-		//	|	new C().destroy();
-		//	|	// prints:
-		//	|	// B.constructor
-		//	|	// C.constructor
-		//	|	// C.destroy
-		//	|	// B.destroy
-		//
-		//	example:
-		//	|	var A = dojo.declare(null, {
-		//	|		"-chains-": {
-		//	|			constructor: "manual"
-		//	|		}
-		//	|	});
-		//	|	var B = dojo.declare(A, {
-		//	|		constructor: function(){
-		//	|			// ...
-		//	|			// call the base constructor with new parameters
-		//	|			this.inherited(arguments, [1, 2, 3]);
-		//	|			// ...
-		//	|		}
-		//	|	});
-		//
-		//	example:
-		//	|	var A = dojo.declare(null, {
-		//	|		"-chains-": {
-		//	|			m1: "before"
-		//	|		},
-		//	|		m1: function(){
-		//	|			console.log("A.m1");
-		//	|		},
-		//	|		m2: function(){
-		//	|			console.log("A.m2");
-		//	|		}
-		//	|	});
-		//	|	var B = dojo.declare(A, {
-		//	|		"-chains-": {
-		//	|			m2: "after"
-		//	|		},
-		//	|		m1: function(){
-		//	|			console.log("B.m1");
-		//	|		},
-		//	|		m2: function(){
-		//	|			console.log("B.m2");
-		//	|		}
-		//	|	});
-		//	|	var x = new B();
-		//	|	x.m1();
-		//	|	// prints:
-		//	|	// B.m1
-		//	|	// A.m1
-		//	|	x.m2();
-		//	|	// prints:
-		//	|	// A.m2
-		//	|	// B.m2
-		return new Function(); // Function
-	};
-	=====*/
-
-	/*=====
-	dojo.safeMixin = function(target, source){
-		//	summary:
-		//		Mix in properties skipping a constructor and decorating functions
-		//		like it is done by dojo.declare.
-		//	target: Object
-		//		Target object to accept new properties.
-		//	source: Object
-		//		Source object for new properties.
-		//	description:
-		//		This function is used to mix in properties like dojo._mixin does,
-		//		but it skips a constructor property and decorates functions like
-		//		dojo.declare does.
-		//
-		//		It is meant to be used with classes and objects produced with
-		//		dojo.declare. Functions mixed in with dojo.safeMixin can use
-		//		this.inherited() like normal methods.
-		//
-		//		This function is used to implement extend() method of a constructor
-		//		produced with dojo.declare().
-		//
-		//	example:
-		//	|	var A = dojo.declare(null, {
-		//	|		m1: function(){
-		//	|			console.log("A.m1");
-		//	|		},
-		//	|		m2: function(){
-		//	|			console.log("A.m2");
-		//	|		}
-		//	|	});
-		//	|	var B = dojo.declare(A, {
-		//	|		m1: function(){
-		//	|			this.inherited(arguments);
-		//	|			console.log("B.m1");
-		//	|		}
-		//	|	});
-		//	|	B.extend({
-		//	|		m2: function(){
-		//	|			this.inherited(arguments);
-		//	|			console.log("B.m2");
-		//	|		}
-		//	|	});
-		//	|	var x = new B();
-		//	|	dojo.safeMixin(x, {
-		//	|		m1: function(){
-		//	|			this.inherited(arguments);
-		//	|			console.log("X.m1");
-		//	|		},
-		//	|		m2: function(){
-		//	|			this.inherited(arguments);
-		//	|			console.log("X.m2");
-		//	|		}
-		//	|	});
-		//	|	x.m2();
-		//	|	// prints:
-		//	|	// A.m1
-		//	|	// B.m1
-		//	|	// X.m1
-	};
-	=====*/
-
-	/*=====
-	Object.inherited = function(name, args, newArgs){
-		//	summary:
-		//		Calls a super method.
-		//	name: String?
-		//		The optional method name. Should be the same as the caller's
-		//		name. Usually "name" is specified in complex dynamic cases, when
-		//		the calling method was dynamically added, undecorated by
-		//		dojo.declare, and it cannot be determined.
-		//	args: Arguments
-		//		The caller supply this argument, which should be the original
-		//		"arguments".
-		//	newArgs: Object?
-		//		If "true", the found function will be returned without
-		//		executing it.
-		//		If Array, it will be used to call a super method. Otherwise
-		//		"args" will be used.
-		//	returns:
-		//		Whatever is returned by a super method, or a super method itself,
-		//		if "true" was specified as newArgs.
-		//	description:
-		//		This method is used inside method of classes produced with
-		//		dojo.declare to call a super method (next in the chain). It is
-		//		used for manually controlled chaining. Consider using the regular
-		//		chaining, because it is faster. Use "this.inherited()" only in
-		//		complex cases.
-		//
-		//		This method cannot me called from automatically chained
-		//		constructors including the case of a special (legacy)
-		//		constructor chaining. It cannot be called from chained methods.
-		//
-		//		If "this.inherited()" cannot find the next-in-chain method, it
-		//		does nothing and returns "undefined". The last method in chain
-		//		can be a default method implemented in Object, which will be
-		//		called last.
-		//
-		//		If "name" is specified, it is assumed that the method that
-		//		received "args" is the parent method for this call. It is looked
-		//		up in the chain list and if it is found the next-in-chain method
-		//		is called. If it is not found, the first-in-chain method is
-		//		called.
-		//
-		//		If "name" is not specified, it will be derived from the calling
-		//		method (using a methoid property "nom").
-		//
-		//	example:
-		//	|	var B = dojo.declare(A, {
-		//	|		method1: function(a, b, c){
-		//	|			this.inherited(arguments);
-		//	|		},
-		//	|		method2: function(a, b){
-		//	|			return this.inherited(arguments, [a + b]);
-		//	|		}
-		//	|	});
-		//	|	// next method is not in the chain list because it is added
-		//	|	// manually after the class was created.
-		//	|	B.prototype.method3 = function(){
-		//	|		console.log("This is a dynamically-added method.");
-		//	|		this.inherited("method3", arguments);
-		//	|	};
-		//	example:
-		//	|	var B = dojo.declare(A, {
-		//	|		method: function(a, b){
-		//	|			var super = this.inherited(arguments, true);
-		//	|			// ...
-		//	|			if(!super){
-		//	|				console.log("there is no super method");
-		//	|				return 0;
-		//	|			}
-		//	|			return super.apply(this, arguments);
-		//	|		}
-		//	|	});
-		return	{};	// Object
-	}
-	=====*/
-
-	/*=====
-	Object.getInherited = function(name, args){
-		//	summary:
-		//		Returns a super method.
-		//	name: String?
-		//		The optional method name. Should be the same as the caller's
-		//		name. Usually "name" is specified in complex dynamic cases, when
-		//		the calling method was dynamically added, undecorated by
-		//		dojo.declare, and it cannot be determined.
-		//	args: Arguments
-		//		The caller supply this argument, which should be the original
-		//		"arguments".
-		//	returns:
-		//		Returns a super method (Function) or "undefined".
-		//	description:
-		//		This method is a convenience method for "this.inherited()".
-		//		It uses the same algorithm but instead of executing a super
-		//		method, it returns it, or "undefined" if not found.
-		//
-		//	example:
-		//	|	var B = dojo.declare(A, {
-		//	|		method: function(a, b){
-		//	|			var super = this.getInherited(arguments);
-		//	|			// ...
-		//	|			if(!super){
-		//	|				console.log("there is no super method");
-		//	|				return 0;
-		//	|			}
-		//	|			return super.apply(this, arguments);
-		//	|		}
-		//	|	});
-		return	{};	// Object
-	}
-	=====*/
-
-	/*=====
-	Object.isInstanceOf = function(cls){
-		//	summary:
-		//		Checks the inheritance chain to see if it is inherited from this
-		//		class.
-		//	cls: Function
-		//		Class constructor.
-		//	returns:
-		//		"true", if this object is inherited from this class, "false"
-		//		otherwise.
-		//	description:
-		//		This method is used with instances of classes produced with
-		//		dojo.declare to determine of they support a certain interface or
-		//		not. It models "instanceof" operator.
-		//
-		//	example:
-		//	|	var A = dojo.declare(null, {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//	|	var B = dojo.declare(null, {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//	|	var C = dojo.declare([A, B], {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//	|	var D = dojo.declare(A, {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//	|
-		//	|	var a = new A(), b = new B(), c = new C(), d = new D();
-		//	|
-		//	|	console.log(a.isInstanceOf(A)); // true
-		//	|	console.log(b.isInstanceOf(A)); // false
-		//	|	console.log(c.isInstanceOf(A)); // true
-		//	|	console.log(d.isInstanceOf(A)); // true
-		//	|
-		//	|	console.log(a.isInstanceOf(B)); // false
-		//	|	console.log(b.isInstanceOf(B)); // true
-		//	|	console.log(c.isInstanceOf(B)); // true
-		//	|	console.log(d.isInstanceOf(B)); // false
-		//	|
-		//	|	console.log(a.isInstanceOf(C)); // false
-		//	|	console.log(b.isInstanceOf(C)); // false
-		//	|	console.log(c.isInstanceOf(C)); // true
-		//	|	console.log(d.isInstanceOf(C)); // false
-		//	|
-		//	|	console.log(a.isInstanceOf(D)); // false
-		//	|	console.log(b.isInstanceOf(D)); // false
-		//	|	console.log(c.isInstanceOf(D)); // false
-		//	|	console.log(d.isInstanceOf(D)); // true
-		return	{};	// Object
-	}
-	=====*/
-
-	/*=====
-	Object.extend = function(source){
-		//	summary:
-		//		Adds all properties and methods of source to constructor's
-		//		prototype, making them available to all instances created with
-		//		constructor. This method is specific to constructors created with
-		//		dojo.declare.
-		//	source: Object
-		//		Source object which properties are going to be copied to the
-		//		constructor's prototype.
-		//	description:
-		//		Adds source properties to the constructor's prototype. It can
-		//		override existing properties.
-		//
-		//		This method is similar to dojo.extend function, but it is specific
-		//		to constructors produced by dojo.declare. It is implemented
-		//		using dojo.safeMixin, and it skips a constructor property,
-		//		and properly decorates copied functions.
-		//
-		//	example:
-		//	|	var A = dojo.declare(null, {
-		//	|		m1: function(){},
-		//	|		s1: "Popokatepetl"
-		//	|	});
-		//	|	A.extend({
-		//	|		m1: function(){},
-		//	|		m2: function(){},
-		//	|		f1: true,
-		//	|		d1: 42
-		//	|	});
-	};
-	=====*/
-})();
-
-}
+//>>built
+define("dojo/_base/declare",["./kernel","../has","./lang"],function(_1,_2,_3){var _4=_3.mixin,op=Object.prototype,_5=op.toString,_6=new Function,_7=0,_8="constructor";function _9(_a,_b){throw new Error("declare"+(_b?" "+_b:"")+": "+_a);};function _c(_d,_e){var _f=[],_10=[{cls:0,refs:[]}],_11={},_12=1,l=_d.length,i=0,j,lin,_13,top,_14,rec,_15,_16;for(;i<l;++i){_13=_d[i];if(!_13){_9("mixin #"+i+" is unknown. Did you use dojo.require to pull it in?",_e);}else{if(_5.call(_13)!="[object Function]"){_9("mixin #"+i+" is not a callable constructor.",_e);}}lin=_13._meta?_13._meta.bases:[_13];top=0;for(j=lin.length-1;j>=0;--j){_14=lin[j].prototype;if(!_14.hasOwnProperty("declaredClass")){_14.declaredClass="uniqName_"+(_7++);}_15=_14.declaredClass;if(!_11.hasOwnProperty(_15)){_11[_15]={count:0,refs:[],cls:lin[j]};++_12;}rec=_11[_15];if(top&&top!==rec){rec.refs.push(top);++top.count;}top=rec;}++top.count;_10[0].refs.push(top);}while(_10.length){top=_10.pop();_f.push(top.cls);--_12;while(_16=top.refs,_16.length==1){top=_16[0];if(!top||--top.count){top=0;break;}_f.push(top.cls);--_12;}if(top){for(i=0,l=_16.length;i<l;++i){top=_16[i];if(!--top.count){_10.push(top);}}}}if(_12){_9("can't build consistent linearization",_e);}_13=_d[0];_f[0]=_13?_13._meta&&_13===_f[_f.length-_13._meta.bases.length]?_13._meta.bases.length:1:0;return _f;};function _17(_18,a,f){var _19,_1a,_1b,_1c,_1d,_1e,_1f,opf,pos,_20=this._inherited=this._inherited||{};if(typeof _18=="string"){_19=_18;_18=a;a=f;}f=0;_1c=_18.callee;_19=_19||_1c.nom;if(!_19){_9("can't deduce a name to call inherited()",this.declaredClass);}_1d=this.constructor._meta;_1b=_1d.bases;pos=_20.p;if(_19!=_8){if(_20.c!==_1c){pos=0;_1e=_1b[0];_1d=_1e._meta;if(_1d.hidden[_19]!==_1c){_1a=_1d.chains;if(_1a&&typeof _1a[_19]=="string"){_9("calling chained method with inherited: "+_19,this.declaredClass);}do{_1d=_1e._meta;_1f=_1e.prototype;if(_1d&&(_1f[_19]===_1c&&_1f.hasOwnProperty(_19)||_1d.hidden[_19]===_1c)){break;}}while(_1e=_1b[++pos]);pos=_1e?pos:-1;}}_1e=_1b[++pos];if(_1e){_1f=_1e.prototype;if(_1e._meta&&_1f.hasOwnProperty(_19)){f=_1f[_19];}else{opf=op[_19];do{_1f=_1e.prototype;f=_1f[_19];if(f&&(_1e._meta?_1f.hasOwnProperty(_19):f!==opf)){break;}}while(_1e=_1b[++pos]);}}f=_1e&&f||op[_19];}else{if(_20.c!==_1c){pos=0;_1d=_1b[0]._meta;if(_1d&&_1d.ctor!==_1c){_1a=_1d.chains;if(!_1a||_1a.constructor!=="manual"){_9("calling chained constructor with inherited",this.declaredClass);}while(_1e=_1b[++pos]){_1d=_1e._meta;if(_1d&&_1d.ctor===_1c){break;}}pos=_1e?pos:-1;}}while(_1e=_1b[++pos]){_1d=_1e._meta;f=_1d?_1d.ctor:_1e;if(f){break;}}f=_1e&&f;}_20.c=f;_20.p=pos;if(f){return a===true?f:f.apply(this,a||_18);}};function _21(_22,_23){if(typeof _22=="string"){return this.__inherited(_22,_23,true);}return this.__inherited(_22,true);};function _24(_25,a1,a2){var f=this.getInherited(_25,a1);if(f){return f.apply(this,a2||a1||_25);}};var _26=_1.config.isDebug?_24:_17;function _27(cls){var _28=this.constructor._meta.bases;for(var i=0,l=_28.length;i<l;++i){if(_28[i]===cls){return true;}}return this instanceof cls;};function _29(_2a,_2b){for(var _2c in _2b){if(_2c!=_8&&_2b.hasOwnProperty(_2c)){_2a[_2c]=_2b[_2c];}}if(_2("bug-for-in-skips-shadowed")){for(var _2d=_3._extraNames,i=_2d.length;i;){_2c=_2d[--i];if(_2c!=_8&&_2b.hasOwnProperty(_2c)){_2a[_2c]=_2b[_2c];}}}};function _2e(_2f,_30){var _31,t;for(_31 in _30){t=_30[_31];if((t!==op[_31]||!(_31 in op))&&_31!=_8){if(_5.call(t)=="[object Function]"){t.nom=_31;}_2f[_31]=t;}}if(_2("bug-for-in-skips-shadowed")){for(var _32=_3._extraNames,i=_32.length;i;){_31=_32[--i];t=_30[_31];if((t!==op[_31]||!(_31 in op))&&_31!=_8){if(_5.call(t)=="[object Function]"){t.nom=_31;}_2f[_31]=t;}}}return _2f;};function _33(_34){_35.safeMixin(this.prototype,_34);return this;};function _36(_37,_38){return function(){var a=arguments,_39=a,a0=a[0],f,i,m,l=_37.length,_3a;if(!(this instanceof a.callee)){return _3b(a);}if(_38&&(a0&&a0.preamble||this.preamble)){_3a=new Array(_37.length);_3a[0]=a;for(i=0;;){a0=a[0];if(a0){f=a0.preamble;if(f){a=f.apply(this,a)||a;}}f=_37[i].prototype;f=f.hasOwnProperty("preamble")&&f.preamble;if(f){a=f.apply(this,a)||a;}if(++i==l){break;}_3a[i]=a;}}for(i=l-1;i>=0;--i){f=_37[i];m=f._meta;f=m?m.ctor:f;if(f){f.apply(this,_3a?_3a[i]:a);}}f=this.postscript;if(f){f.apply(this,_39);}};};function _3c(_3d,_3e){return function(){var a=arguments,t=a,a0=a[0],f;if(!(this instanceof a.callee)){return _3b(a);}if(_3e){if(a0){f=a0.preamble;if(f){t=f.apply(this,t)||t;}}f=this.preamble;if(f){f.apply(this,t);}}if(_3d){_3d.apply(this,a);}f=this.postscript;if(f){f.apply(this,a);}};};function _3f(_40){return function(){var a=arguments,i=0,f,m;if(!(this instanceof a.callee)){return _3b(a);}for(;f=_40[i];++i){m=f._meta;f=m?m.ctor:f;if(f){f.apply(this,a);break;}}f=this.postscript;if(f){f.apply(this,a);}};};function _41(_42,_43,_44){return function(){var b,m,f,i=0,_45=1;if(_44){i=_43.length-1;_45=-1;}for(;b=_43[i];i+=_45){m=b._meta;f=(m?m.hidden:b.prototype)[_42];if(f){f.apply(this,arguments);}}};};function _46(_47){_6.prototype=_47.prototype;var t=new _6;_6.prototype=null;return t;};function _3b(_48){var _49=_48.callee,t=_46(_49);_49.apply(t,_48);return t;};function _35(_4a,_4b,_4c){if(typeof _4a!="string"){_4c=_4b;_4b=_4a;_4a="";}_4c=_4c||{};var _4d,i,t,_4e,_4f,_50,_51,_52=1,_53=_4b;if(_5.call(_4b)=="[object Array]"){_50=_c(_4b,_4a);t=_50[0];_52=_50.length-t;_4b=_50[_52];}else{_50=[0];if(_4b){if(_5.call(_4b)=="[object Function]"){t=_4b._meta;_50=_50.concat(t?t.bases:_4b);}else{_9("base class is not a callable constructor.",_4a);}}else{if(_4b!==null){_9("unknown base class. Did you use dojo.require to pull it in?",_4a);}}}if(_4b){for(i=_52-1;;--i){_4d=_46(_4b);if(!i){break;}t=_50[i];(t._meta?_29:_4)(_4d,t.prototype);_4e=new Function;_4e.superclass=_4b;_4e.prototype=_4d;_4b=_4d.constructor=_4e;}}else{_4d={};}_35.safeMixin(_4d,_4c);t=_4c.constructor;if(t!==op.constructor){t.nom=_8;_4d.constructor=t;}for(i=_52-1;i;--i){t=_50[i]._meta;if(t&&t.chains){_51=_4(_51||{},t.chains);}}if(_4d["-chains-"]){_51=_4(_51||{},_4d["-chains-"]);}t=!_51||!_51.hasOwnProperty(_8);_50[0]=_4e=(_51&&_51.constructor==="manual")?_3f(_50):(_50.length==1?_3c(_4c.constructor,t):_36(_50,t));_4e._meta={bases:_50,hidden:_4c,chains:_51,parents:_53,ctor:_4c.constructor};_4e.superclass=_4b&&_4b.prototype;_4e.extend=_33;_4e.prototype=_4d;_4d.constructor=_4e;_4d.getInherited=_21;_4d.isInstanceOf=_27;_4d.inherited=_26;_4d.__inherited=_17;if(_4a){_4d.declaredClass=_4a;_3.setObject(_4a,_4e);}if(_51){for(_4f in _51){if(_4d[_4f]&&typeof _51[_4f]=="string"&&_4f!=_8){t=_4d[_4f]=_41(_4f,_50,_51[_4f]==="after");t.nom=_4f;}}}return _4e;};_1.safeMixin=_35.safeMixin=_2e;_1.declare=_35;return _35;});
\ No newline at end of file
diff --git a/lib/dojo/_base/declare.js.uncompressed.js b/lib/dojo/_base/declare.js.uncompressed.js
new file mode 100644
index 000000000..838bf1c81
--- /dev/null
+++ b/lib/dojo/_base/declare.js.uncompressed.js
@@ -0,0 +1,1050 @@
+define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, has, lang){
+	// module:
+	//		dojo/_base/declare
+	// summary:
+	//		This module defines dojo.declare.
+
+	var mix = lang.mixin, op = Object.prototype, opts = op.toString,
+		xtor = new Function, counter = 0, cname = "constructor";
+
+	function err(msg, cls){ throw new Error("declare" + (cls ? " " + cls : "") + ": " + msg); }
+
+	// C3 Method Resolution Order (see http://www.python.org/download/releases/2.3/mro/)
+	function c3mro(bases, className){
+		var result = [], roots = [{cls: 0, refs: []}], nameMap = {}, clsCount = 1,
+			l = bases.length, i = 0, j, lin, base, top, proto, rec, name, refs;
+
+		// build a list of bases naming them if needed
+		for(; i < l; ++i){
+			base = bases[i];
+			if(!base){
+				err("mixin #" + i + " is unknown. Did you use dojo.require to pull it in?", className);
+			}else if(opts.call(base) != "[object Function]"){
+				err("mixin #" + i + " is not a callable constructor.", className);
+			}
+			lin = base._meta ? base._meta.bases : [base];
+			top = 0;
+			// add bases to the name map
+			for(j = lin.length - 1; j >= 0; --j){
+				proto = lin[j].prototype;
+				if(!proto.hasOwnProperty("declaredClass")){
+					proto.declaredClass = "uniqName_" + (counter++);
+				}
+				name = proto.declaredClass;
+				if(!nameMap.hasOwnProperty(name)){
+					nameMap[name] = {count: 0, refs: [], cls: lin[j]};
+					++clsCount;
+				}
+				rec = nameMap[name];
+				if(top && top !== rec){
+					rec.refs.push(top);
+					++top.count;
+				}
+				top = rec;
+			}
+			++top.count;
+			roots[0].refs.push(top);
+		}
+
+		// remove classes without external references recursively
+		while(roots.length){
+			top = roots.pop();
+			result.push(top.cls);
+			--clsCount;
+			// optimization: follow a single-linked chain
+			while(refs = top.refs, refs.length == 1){
+				top = refs[0];
+				if(!top || --top.count){
+					// branch or end of chain => do not end to roots
+					top = 0;
+					break;
+				}
+				result.push(top.cls);
+				--clsCount;
+			}
+			if(top){
+				// branch
+				for(i = 0, l = refs.length; i < l; ++i){
+					top = refs[i];
+					if(!--top.count){
+						roots.push(top);
+					}
+				}
+			}
+		}
+		if(clsCount){
+			err("can't build consistent linearization", className);
+		}
+
+		// calculate the superclass offset
+		base = bases[0];
+		result[0] = base ?
+			base._meta && base === result[result.length - base._meta.bases.length] ?
+				base._meta.bases.length : 1 : 0;
+
+		return result;
+	}
+
+	function inherited(args, a, f){
+		var name, chains, bases, caller, meta, base, proto, opf, pos,
+			cache = this._inherited = this._inherited || {};
+
+		// crack arguments
+		if(typeof args == "string"){
+			name = args;
+			args = a;
+			a = f;
+		}
+		f = 0;
+
+		caller = args.callee;
+		name = name || caller.nom;
+		if(!name){
+			err("can't deduce a name to call inherited()", this.declaredClass);
+		}
+
+		meta = this.constructor._meta;
+		bases = meta.bases;
+
+		pos = cache.p;
+		if(name != cname){
+			// method
+			if(cache.c !== caller){
+				// cache bust
+				pos = 0;
+				base = bases[0];
+				meta = base._meta;
+				if(meta.hidden[name] !== caller){
+					// error detection
+					chains = meta.chains;
+					if(chains && typeof chains[name] == "string"){
+						err("calling chained method with inherited: " + name, this.declaredClass);
+					}
+					// find caller
+					do{
+						meta = base._meta;
+						proto = base.prototype;
+						if(meta && (proto[name] === caller && proto.hasOwnProperty(name) || meta.hidden[name] === caller)){
+							break;
+						}
+					}while(base = bases[++pos]); // intentional assignment
+					pos = base ? pos : -1;
+				}
+			}
+			// find next
+			base = bases[++pos];
+			if(base){
+				proto = base.prototype;
+				if(base._meta && proto.hasOwnProperty(name)){
+					f = proto[name];
+				}else{
+					opf = op[name];
+					do{
+						proto = base.prototype;
+						f = proto[name];
+						if(f && (base._meta ? proto.hasOwnProperty(name) : f !== opf)){
+							break;
+						}
+					}while(base = bases[++pos]); // intentional assignment
+				}
+			}
+			f = base && f || op[name];
+		}else{
+			// constructor
+			if(cache.c !== caller){
+				// cache bust
+				pos = 0;
+				meta = bases[0]._meta;
+				if(meta && meta.ctor !== caller){
+					// error detection
+					chains = meta.chains;
+					if(!chains || chains.constructor !== "manual"){
+						err("calling chained constructor with inherited", this.declaredClass);
+					}
+					// find caller
+					while(base = bases[++pos]){ // intentional assignment
+						meta = base._meta;
+						if(meta && meta.ctor === caller){
+							break;
+						}
+					}
+					pos = base ? pos : -1;
+				}
+			}
+			// find next
+			while(base = bases[++pos]){	// intentional assignment
+				meta = base._meta;
+				f = meta ? meta.ctor : base;
+				if(f){
+					break;
+				}
+			}
+			f = base && f;
+		}
+
+		// cache the found super method
+		cache.c = f;
+		cache.p = pos;
+
+		// now we have the result
+		if(f){
+			return a === true ? f : f.apply(this, a || args);
+		}
+		// intentionally no return if a super method was not found
+	}
+
+	function getInherited(name, args){
+		if(typeof name == "string"){
+			return this.__inherited(name, args, true);
+		}
+		return this.__inherited(name, true);
+	}
+
+	function inherited__debug(args, a1, a2){
+		var f = this.getInherited(args, a1);
+		if(f){ return f.apply(this, a2 || a1 || args); }
+		// intentionally no return if a super method was not found
+	}
+
+	var inheritedImpl = dojo.config.isDebug ? inherited__debug : inherited;
+
+	// emulation of "instanceof"
+	function isInstanceOf(cls){
+		var bases = this.constructor._meta.bases;
+		for(var i = 0, l = bases.length; i < l; ++i){
+			if(bases[i] === cls){
+				return true;
+			}
+		}
+		return this instanceof cls;
+	}
+
+	function mixOwn(target, source){
+		// add props adding metadata for incoming functions skipping a constructor
+		for(var name in source){
+			if(name != cname && source.hasOwnProperty(name)){
+				target[name] = source[name];
+			}
+		}
+		if(has("bug-for-in-skips-shadowed")){
+			for(var extraNames= lang._extraNames, i= extraNames.length; i;){
+				name = extraNames[--i];
+				if(name != cname && source.hasOwnProperty(name)){
+					  target[name] = source[name];
+				}
+			}
+		}
+	}
+
+	// implementation of safe mixin function
+	function safeMixin(target, source){
+		var name, t;
+		// add props adding metadata for incoming functions skipping a constructor
+		for(name in source){
+			t = source[name];
+			if((t !== op[name] || !(name in op)) && name != cname){
+				if(opts.call(t) == "[object Function]"){
+					// non-trivial function method => attach its name
+					t.nom = name;
+				}
+				target[name] = t;
+			}
+		}
+		if(has("bug-for-in-skips-shadowed")){
+			for(var extraNames= lang._extraNames, i= extraNames.length; i;){
+				name = extraNames[--i];
+				t = source[name];
+				if((t !== op[name] || !(name in op)) && name != cname){
+					if(opts.call(t) == "[object Function]"){
+						// non-trivial function method => attach its name
+						  t.nom = name;
+					}
+					target[name] = t;
+				}
+			}
+		}
+		return target;
+	}
+
+	function extend(source){
+		declare.safeMixin(this.prototype, source);
+		return this;
+	}
+
+	// chained constructor compatible with the legacy dojo.declare()
+	function chainedConstructor(bases, ctorSpecial){
+		return function(){
+			var a = arguments, args = a, a0 = a[0], f, i, m,
+				l = bases.length, preArgs;
+
+			if(!(this instanceof a.callee)){
+				// not called via new, so force it
+				return applyNew(a);
+			}
+
+			//this._inherited = {};
+			// perform the shaman's rituals of the original dojo.declare()
+			// 1) call two types of the preamble
+			if(ctorSpecial && (a0 && a0.preamble || this.preamble)){
+				// full blown ritual
+				preArgs = new Array(bases.length);
+				// prepare parameters
+				preArgs[0] = a;
+				for(i = 0;;){
+					// process the preamble of the 1st argument
+					a0 = a[0];
+					if(a0){
+						f = a0.preamble;
+						if(f){
+							a = f.apply(this, a) || a;
+						}
+					}
+					// process the preamble of this class
+					f = bases[i].prototype;
+					f = f.hasOwnProperty("preamble") && f.preamble;
+					if(f){
+						a = f.apply(this, a) || a;
+					}
+					// one peculiarity of the preamble:
+					// it is called if it is not needed,
+					// e.g., there is no constructor to call
+					// let's watch for the last constructor
+					// (see ticket #9795)
+					if(++i == l){
+						break;
+					}
+					preArgs[i] = a;
+				}
+			}
+			// 2) call all non-trivial constructors using prepared arguments
+			for(i = l - 1; i >= 0; --i){
+				f = bases[i];
+				m = f._meta;
+				f = m ? m.ctor : f;
+				if(f){
+					f.apply(this, preArgs ? preArgs[i] : a);
+				}
+			}
+			// 3) continue the original ritual: call the postscript
+			f = this.postscript;
+			if(f){
+				f.apply(this, args);
+			}
+		};
+	}
+
+
+	// chained constructor compatible with the legacy dojo.declare()
+	function singleConstructor(ctor, ctorSpecial){
+		return function(){
+			var a = arguments, t = a, a0 = a[0], f;
+
+			if(!(this instanceof a.callee)){
+				// not called via new, so force it
+				return applyNew(a);
+			}
+
+			//this._inherited = {};
+			// perform the shaman's rituals of the original dojo.declare()
+			// 1) call two types of the preamble
+			if(ctorSpecial){
+				// full blown ritual
+				if(a0){
+					// process the preamble of the 1st argument
+					f = a0.preamble;
+					if(f){
+						t = f.apply(this, t) || t;
+					}
+				}
+				f = this.preamble;
+				if(f){
+					// process the preamble of this class
+					f.apply(this, t);
+					// one peculiarity of the preamble:
+					// it is called even if it is not needed,
+					// e.g., there is no constructor to call
+					// let's watch for the last constructor
+					// (see ticket #9795)
+				}
+			}
+			// 2) call a constructor
+			if(ctor){
+				ctor.apply(this, a);
+			}
+			// 3) continue the original ritual: call the postscript
+			f = this.postscript;
+			if(f){
+				f.apply(this, a);
+			}
+		};
+	}
+
+	// plain vanilla constructor (can use inherited() to call its base constructor)
+	function simpleConstructor(bases){
+		return function(){
+			var a = arguments, i = 0, f, m;
+
+			if(!(this instanceof a.callee)){
+				// not called via new, so force it
+				return applyNew(a);
+			}
+
+			//this._inherited = {};
+			// perform the shaman's rituals of the original dojo.declare()
+			// 1) do not call the preamble
+			// 2) call the top constructor (it can use this.inherited())
+			for(; f = bases[i]; ++i){ // intentional assignment
+				m = f._meta;
+				f = m ? m.ctor : f;
+				if(f){
+					f.apply(this, a);
+					break;
+				}
+			}
+			// 3) call the postscript
+			f = this.postscript;
+			if(f){
+				f.apply(this, a);
+			}
+		};
+	}
+
+	function chain(name, bases, reversed){
+		return function(){
+			var b, m, f, i = 0, step = 1;
+			if(reversed){
+				i = bases.length - 1;
+				step = -1;
+			}
+			for(; b = bases[i]; i += step){ // intentional assignment
+				m = b._meta;
+				f = (m ? m.hidden : b.prototype)[name];
+				if(f){
+					f.apply(this, arguments);
+				}
+			}
+		};
+	}
+
+	// forceNew(ctor)
+	// return a new object that inherits from ctor.prototype but
+	// without actually running ctor on the object.
+	function forceNew(ctor){
+		// create object with correct prototype using a do-nothing
+		// constructor
+		xtor.prototype = ctor.prototype;
+		var t = new xtor;
+		xtor.prototype = null;	// clean up
+		return t;
+	}
+
+	// applyNew(args)
+	// just like 'new ctor()' except that the constructor and its arguments come
+	// from args, which must be an array or an arguments object
+	function applyNew(args){
+		// create an object with ctor's prototype but without
+		// calling ctor on it.
+		var ctor = args.callee, t = forceNew(ctor);
+		// execute the real constructor on the new object
+		ctor.apply(t, args);
+		return t;
+	}
+
+	function declare(className, superclass, props){
+		// crack parameters
+		if(typeof className != "string"){
+			props = superclass;
+			superclass = className;
+			className = "";
+		}
+		props = props || {};
+
+		var proto, i, t, ctor, name, bases, chains, mixins = 1, parents = superclass;
+
+		// build a prototype
+		if(opts.call(superclass) == "[object Array]"){
+			// C3 MRO
+			bases = c3mro(superclass, className);
+			t = bases[0];
+			mixins = bases.length - t;
+			superclass = bases[mixins];
+		}else{
+			bases = [0];
+			if(superclass){
+				if(opts.call(superclass) == "[object Function]"){
+					t = superclass._meta;
+					bases = bases.concat(t ? t.bases : superclass);
+				}else{
+					err("base class is not a callable constructor.", className);
+				}
+			}else if(superclass !== null){
+				err("unknown base class. Did you use dojo.require to pull it in?", className);
+			}
+		}
+		if(superclass){
+			for(i = mixins - 1;; --i){
+				proto = forceNew(superclass);
+				if(!i){
+					// stop if nothing to add (the last base)
+					break;
+				}
+				// mix in properties
+				t = bases[i];
+				(t._meta ? mixOwn : mix)(proto, t.prototype);
+				// chain in new constructor
+				ctor = new Function;
+				ctor.superclass = superclass;
+				ctor.prototype = proto;
+				superclass = proto.constructor = ctor;
+			}
+		}else{
+			proto = {};
+		}
+		// add all properties
+		declare.safeMixin(proto, props);
+		// add constructor
+		t = props.constructor;
+		if(t !== op.constructor){
+			t.nom = cname;
+			proto.constructor = t;
+		}
+
+		// collect chains and flags
+		for(i = mixins - 1; i; --i){ // intentional assignment
+			t = bases[i]._meta;
+			if(t && t.chains){
+				chains = mix(chains || {}, t.chains);
+			}
+		}
+		if(proto["-chains-"]){
+			chains = mix(chains || {}, proto["-chains-"]);
+		}
+
+		// build ctor
+		t = !chains || !chains.hasOwnProperty(cname);
+		bases[0] = ctor = (chains && chains.constructor === "manual") ? simpleConstructor(bases) :
+			(bases.length == 1 ? singleConstructor(props.constructor, t) : chainedConstructor(bases, t));
+
+		// add meta information to the constructor
+		ctor._meta  = {bases: bases, hidden: props, chains: chains,
+			parents: parents, ctor: props.constructor};
+		ctor.superclass = superclass && superclass.prototype;
+		ctor.extend = extend;
+		ctor.prototype = proto;
+		proto.constructor = ctor;
+
+		// add "standard" methods to the prototype
+		proto.getInherited = getInherited;
+		proto.isInstanceOf = isInstanceOf;
+		proto.inherited    = inheritedImpl;
+		proto.__inherited  = inherited;
+
+		// add name if specified
+		if(className){
+			proto.declaredClass = className;
+			lang.setObject(className, ctor);
+		}
+
+		// build chains and add them to the prototype
+		if(chains){
+			for(name in chains){
+				if(proto[name] && typeof chains[name] == "string" && name != cname){
+					t = proto[name] = chain(name, bases, chains[name] === "after");
+					t.nom = name;
+				}
+			}
+		}
+		// chained methods do not return values
+		// no need to chain "invisible" functions
+
+		return ctor;	// Function
+	}
+
+	/*=====
+	dojo.declare = function(className, superclass, props){
+		//	summary:
+		//		Create a feature-rich constructor from compact notation.
+		//	className: String?:
+		//		The optional name of the constructor (loosely, a "class")
+		//		stored in the "declaredClass" property in the created prototype.
+		//		It will be used as a global name for a created constructor.
+		//	superclass: Function|Function[]:
+		//		May be null, a Function, or an Array of Functions. This argument
+		//		specifies a list of bases (the left-most one is the most deepest
+		//		base).
+		//	props: Object:
+		//		An object whose properties are copied to the created prototype.
+		//		Add an instance-initialization function by making it a property
+		//		named "constructor".
+		//	returns:
+		//		New constructor function.
+		//	description:
+		//		Create a constructor using a compact notation for inheritance and
+		//		prototype extension.
+		//
+		//		Mixin ancestors provide a type of multiple inheritance.
+		//		Prototypes of mixin ancestors are copied to the new class:
+		//		changes to mixin prototypes will not affect classes to which
+		//		they have been mixed in.
+		//
+		//		Ancestors can be compound classes created by this version of
+		//		dojo.declare. In complex cases all base classes are going to be
+		//		linearized according to C3 MRO algorithm
+		//		(see http://www.python.org/download/releases/2.3/mro/ for more
+		//		details).
+		//
+		//		"className" is cached in "declaredClass" property of the new class,
+		//		if it was supplied. The immediate super class will be cached in
+		//		"superclass" property of the new class.
+		//
+		//		Methods in "props" will be copied and modified: "nom" property
+		//		(the declared name of the method) will be added to all copied
+		//		functions to help identify them for the internal machinery. Be
+		//		very careful, while reusing methods: if you use the same
+		//		function under different names, it can produce errors in some
+		//		cases.
+		//
+		//		It is possible to use constructors created "manually" (without
+		//		dojo.declare) as bases. They will be called as usual during the
+		//		creation of an instance, their methods will be chained, and even
+		//		called by "this.inherited()".
+		//
+		//		Special property "-chains-" governs how to chain methods. It is
+		//		a dictionary, which uses method names as keys, and hint strings
+		//		as values. If a hint string is "after", this method will be
+		//		called after methods of its base classes. If a hint string is
+		//		"before", this method will be called before methods of its base
+		//		classes.
+		//
+		//		If "constructor" is not mentioned in "-chains-" property, it will
+		//		be chained using the legacy mode: using "after" chaining,
+		//		calling preamble() method before each constructor, if available,
+		//		and calling postscript() after all constructors were executed.
+		//		If the hint is "after", it is chained as a regular method, but
+		//		postscript() will be called after the chain of constructors.
+		//		"constructor" cannot be chained "before", but it allows
+		//		a special hint string: "manual", which means that constructors
+		//		are not going to be chained in any way, and programmer will call
+		//		them manually using this.inherited(). In the latter case
+		//		postscript() will be called after the construction.
+		//
+		//		All chaining hints are "inherited" from base classes and
+		//		potentially can be overridden. Be very careful when overriding
+		//		hints! Make sure that all chained methods can work in a proposed
+		//		manner of chaining.
+		//
+		//		Once a method was chained, it is impossible to unchain it. The
+		//		only exception is "constructor". You don't need to define a
+		//		method in order to supply a chaining hint.
+		//
+		//		If a method is chained, it cannot use this.inherited() because
+		//		all other methods in the hierarchy will be called automatically.
+		//
+		//		Usually constructors and initializers of any kind are chained
+		//		using "after" and destructors of any kind are chained as
+		//		"before". Note that chaining assumes that chained methods do not
+		//		return any value: any returned value will be discarded.
+		//
+		//	example:
+		//	|	dojo.declare("my.classes.bar", my.classes.foo, {
+		//	|		// properties to be added to the class prototype
+		//	|		someValue: 2,
+		//	|		// initialization function
+		//	|		constructor: function(){
+		//	|			this.myComplicatedObject = new ReallyComplicatedObject();
+		//	|		},
+		//	|		// other functions
+		//	|		someMethod: function(){
+		//	|			doStuff();
+		//	|		}
+		//	|	});
+		//
+		//	example:
+		//	|	var MyBase = dojo.declare(null, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var MyClass1 = dojo.declare(MyBase, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var MyClass2 = dojo.declare(MyBase, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var MyDiamond = dojo.declare([MyClass1, MyClass2], {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//
+		//	example:
+		//	|	var F = function(){ console.log("raw constructor"); };
+		//	|	F.prototype.method = function(){
+		//	|		console.log("raw method");
+		//	|	};
+		//	|	var A = dojo.declare(F, {
+		//	|		constructor: function(){
+		//	|			console.log("A.constructor");
+		//	|		},
+		//	|		method: function(){
+		//	|			console.log("before calling F.method...");
+		//	|			this.inherited(arguments);
+		//	|			console.log("...back in A");
+		//	|		}
+		//	|	});
+		//	|	new A().method();
+		//	|	// will print:
+		//	|	// raw constructor
+		//	|	// A.constructor
+		//	|	// before calling F.method...
+		//	|	// raw method
+		//	|	// ...back in A
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		"-chains-": {
+		//	|			destroy: "before"
+		//	|		}
+		//	|	});
+		//	|	var B = dojo.declare(A, {
+		//	|		constructor: function(){
+		//	|			console.log("B.constructor");
+		//	|		},
+		//	|		destroy: function(){
+		//	|			console.log("B.destroy");
+		//	|		}
+		//	|	});
+		//	|	var C = dojo.declare(B, {
+		//	|		constructor: function(){
+		//	|			console.log("C.constructor");
+		//	|		},
+		//	|		destroy: function(){
+		//	|			console.log("C.destroy");
+		//	|		}
+		//	|	});
+		//	|	new C().destroy();
+		//	|	// prints:
+		//	|	// B.constructor
+		//	|	// C.constructor
+		//	|	// C.destroy
+		//	|	// B.destroy
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		"-chains-": {
+		//	|			constructor: "manual"
+		//	|		}
+		//	|	});
+		//	|	var B = dojo.declare(A, {
+		//	|		constructor: function(){
+		//	|			// ...
+		//	|			// call the base constructor with new parameters
+		//	|			this.inherited(arguments, [1, 2, 3]);
+		//	|			// ...
+		//	|		}
+		//	|	});
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		"-chains-": {
+		//	|			m1: "before"
+		//	|		},
+		//	|		m1: function(){
+		//	|			console.log("A.m1");
+		//	|		},
+		//	|		m2: function(){
+		//	|			console.log("A.m2");
+		//	|		}
+		//	|	});
+		//	|	var B = dojo.declare(A, {
+		//	|		"-chains-": {
+		//	|			m2: "after"
+		//	|		},
+		//	|		m1: function(){
+		//	|			console.log("B.m1");
+		//	|		},
+		//	|		m2: function(){
+		//	|			console.log("B.m2");
+		//	|		}
+		//	|	});
+		//	|	var x = new B();
+		//	|	x.m1();
+		//	|	// prints:
+		//	|	// B.m1
+		//	|	// A.m1
+		//	|	x.m2();
+		//	|	// prints:
+		//	|	// A.m2
+		//	|	// B.m2
+		return new Function(); // Function
+	};
+	=====*/
+
+	/*=====
+	dojo.safeMixin = function(target, source){
+		//	summary:
+		//		Mix in properties skipping a constructor and decorating functions
+		//		like it is done by dojo.declare.
+		//	target: Object
+		//		Target object to accept new properties.
+		//	source: Object
+		//		Source object for new properties.
+		//	description:
+		//		This function is used to mix in properties like lang.mixin does,
+		//		but it skips a constructor property and decorates functions like
+		//		dojo.declare does.
+		//
+		//		It is meant to be used with classes and objects produced with
+		//		dojo.declare. Functions mixed in with dojo.safeMixin can use
+		//		this.inherited() like normal methods.
+		//
+		//		This function is used to implement extend() method of a constructor
+		//		produced with dojo.declare().
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		m1: function(){
+		//	|			console.log("A.m1");
+		//	|		},
+		//	|		m2: function(){
+		//	|			console.log("A.m2");
+		//	|		}
+		//	|	});
+		//	|	var B = dojo.declare(A, {
+		//	|		m1: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("B.m1");
+		//	|		}
+		//	|	});
+		//	|	B.extend({
+		//	|		m2: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("B.m2");
+		//	|		}
+		//	|	});
+		//	|	var x = new B();
+		//	|	dojo.safeMixin(x, {
+		//	|		m1: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("X.m1");
+		//	|		},
+		//	|		m2: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("X.m2");
+		//	|		}
+		//	|	});
+		//	|	x.m2();
+		//	|	// prints:
+		//	|	// A.m1
+		//	|	// B.m1
+		//	|	// X.m1
+	};
+	=====*/
+
+	/*=====
+	Object.inherited = function(name, args, newArgs){
+		//	summary:
+		//		Calls a super method.
+		//	name: String?
+		//		The optional method name. Should be the same as the caller's
+		//		name. Usually "name" is specified in complex dynamic cases, when
+		//		the calling method was dynamically added, undecorated by
+		//		dojo.declare, and it cannot be determined.
+		//	args: Arguments
+		//		The caller supply this argument, which should be the original
+		//		"arguments".
+		//	newArgs: Object?
+		//		If "true", the found function will be returned without
+		//		executing it.
+		//		If Array, it will be used to call a super method. Otherwise
+		//		"args" will be used.
+		//	returns:
+		//		Whatever is returned by a super method, or a super method itself,
+		//		if "true" was specified as newArgs.
+		//	description:
+		//		This method is used inside method of classes produced with
+		//		dojo.declare to call a super method (next in the chain). It is
+		//		used for manually controlled chaining. Consider using the regular
+		//		chaining, because it is faster. Use "this.inherited()" only in
+		//		complex cases.
+		//
+		//		This method cannot me called from automatically chained
+		//		constructors including the case of a special (legacy)
+		//		constructor chaining. It cannot be called from chained methods.
+		//
+		//		If "this.inherited()" cannot find the next-in-chain method, it
+		//		does nothing and returns "undefined". The last method in chain
+		//		can be a default method implemented in Object, which will be
+		//		called last.
+		//
+		//		If "name" is specified, it is assumed that the method that
+		//		received "args" is the parent method for this call. It is looked
+		//		up in the chain list and if it is found the next-in-chain method
+		//		is called. If it is not found, the first-in-chain method is
+		//		called.
+		//
+		//		If "name" is not specified, it will be derived from the calling
+		//		method (using a methoid property "nom").
+		//
+		//	example:
+		//	|	var B = dojo.declare(A, {
+		//	|		method1: function(a, b, c){
+		//	|			this.inherited(arguments);
+		//	|		},
+		//	|		method2: function(a, b){
+		//	|			return this.inherited(arguments, [a + b]);
+		//	|		}
+		//	|	});
+		//	|	// next method is not in the chain list because it is added
+		//	|	// manually after the class was created.
+		//	|	B.prototype.method3 = function(){
+		//	|		console.log("This is a dynamically-added method.");
+		//	|		this.inherited("method3", arguments);
+		//	|	};
+		//	example:
+		//	|	var B = dojo.declare(A, {
+		//	|		method: function(a, b){
+		//	|			var super = this.inherited(arguments, true);
+		//	|			// ...
+		//	|			if(!super){
+		//	|				console.log("there is no super method");
+		//	|				return 0;
+		//	|			}
+		//	|			return super.apply(this, arguments);
+		//	|		}
+		//	|	});
+		return	{};	// Object
+	}
+	=====*/
+
+	/*=====
+	Object.getInherited = function(name, args){
+		//	summary:
+		//		Returns a super method.
+		//	name: String?
+		//		The optional method name. Should be the same as the caller's
+		//		name. Usually "name" is specified in complex dynamic cases, when
+		//		the calling method was dynamically added, undecorated by
+		//		dojo.declare, and it cannot be determined.
+		//	args: Arguments
+		//		The caller supply this argument, which should be the original
+		//		"arguments".
+		//	returns:
+		//		Returns a super method (Function) or "undefined".
+		//	description:
+		//		This method is a convenience method for "this.inherited()".
+		//		It uses the same algorithm but instead of executing a super
+		//		method, it returns it, or "undefined" if not found.
+		//
+		//	example:
+		//	|	var B = dojo.declare(A, {
+		//	|		method: function(a, b){
+		//	|			var super = this.getInherited(arguments);
+		//	|			// ...
+		//	|			if(!super){
+		//	|				console.log("there is no super method");
+		//	|				return 0;
+		//	|			}
+		//	|			return super.apply(this, arguments);
+		//	|		}
+		//	|	});
+		return	{};	// Object
+	}
+	=====*/
+
+	/*=====
+	Object.isInstanceOf = function(cls){
+		//	summary:
+		//		Checks the inheritance chain to see if it is inherited from this
+		//		class.
+		//	cls: Function
+		//		Class constructor.
+		//	returns:
+		//		"true", if this object is inherited from this class, "false"
+		//		otherwise.
+		//	description:
+		//		This method is used with instances of classes produced with
+		//		dojo.declare to determine of they support a certain interface or
+		//		not. It models "instanceof" operator.
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var B = dojo.declare(null, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var C = dojo.declare([A, B], {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var D = dojo.declare(A, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|
+		//	|	var a = new A(), b = new B(), c = new C(), d = new D();
+		//	|
+		//	|	console.log(a.isInstanceOf(A)); // true
+		//	|	console.log(b.isInstanceOf(A)); // false
+		//	|	console.log(c.isInstanceOf(A)); // true
+		//	|	console.log(d.isInstanceOf(A)); // true
+		//	|
+		//	|	console.log(a.isInstanceOf(B)); // false
+		//	|	console.log(b.isInstanceOf(B)); // true
+		//	|	console.log(c.isInstanceOf(B)); // true
+		//	|	console.log(d.isInstanceOf(B)); // false
+		//	|
+		//	|	console.log(a.isInstanceOf(C)); // false
+		//	|	console.log(b.isInstanceOf(C)); // false
+		//	|	console.log(c.isInstanceOf(C)); // true
+		//	|	console.log(d.isInstanceOf(C)); // false
+		//	|
+		//	|	console.log(a.isInstanceOf(D)); // false
+		//	|	console.log(b.isInstanceOf(D)); // false
+		//	|	console.log(c.isInstanceOf(D)); // false
+		//	|	console.log(d.isInstanceOf(D)); // true
+		return	{};	// Object
+	}
+	=====*/
+
+	/*=====
+	Object.extend = function(source){
+		//	summary:
+		//		Adds all properties and methods of source to constructor's
+		//		prototype, making them available to all instances created with
+		//		constructor. This method is specific to constructors created with
+		//		dojo.declare.
+		//	source: Object
+		//		Source object which properties are going to be copied to the
+		//		constructor's prototype.
+		//	description:
+		//		Adds source properties to the constructor's prototype. It can
+		//		override existing properties.
+		//
+		//		This method is similar to dojo.extend function, but it is specific
+		//		to constructors produced by dojo.declare. It is implemented
+		//		using dojo.safeMixin, and it skips a constructor property,
+		//		and properly decorates copied functions.
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		m1: function(){},
+		//	|		s1: "Popokatepetl"
+		//	|	});
+		//	|	A.extend({
+		//	|		m1: function(){},
+		//	|		m2: function(){},
+		//	|		f1: true,
+		//	|		d1: 42
+		//	|	});
+	};
+	=====*/
+
+	dojo.safeMixin = declare.safeMixin = safeMixin;
+	dojo.declare = declare;
+
+	return declare;
+});
diff --git a/lib/dojo/_base/event.js b/lib/dojo/_base/event.js
index 65239bf50..522202d7b 100644
--- a/lib/dojo/_base/event.js
+++ b/lib/dojo/_base/event.js
@@ -4,646 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.event"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.event"] = true;
-dojo.provide("dojo._base.event");
-dojo.require("dojo._base.connect");
-
-
-// this file courtesy of the TurboAjax Group, licensed under a Dojo CLA
-
-(function(){
-	// DOM event listener machinery
-	var del = (dojo._event_listener = {
-		add: function(/*DOMNode*/ node, /*String*/ name, /*Function*/ fp){
-			if(!node){return;}
-			name = del._normalizeEventName(name);
-			fp = del._fixCallback(name, fp);
-			if(
-								!dojo.isIE &&
-								(name == "mouseenter" || name == "mouseleave")
-			){
-				var ofp = fp;
-				name = (name == "mouseenter") ? "mouseover" : "mouseout";
-				fp = function(e){
-					if(!dojo.isDescendant(e.relatedTarget, node)){
-						// e.type = oname; // FIXME: doesn't take? SJM: event.type is generally immutable.
-						return ofp.call(this, e);
-					}
-				}
-			}
-			node.addEventListener(name, fp, false);
-			return fp; /*Handle*/
-		},
-		remove: function(/*DOMNode*/ node, /*String*/ event, /*Handle*/ handle){
-			// summary:
-			//		clobbers the listener from the node
-			// node:
-			//		DOM node to attach the event to
-			// event:
-			//		the name of the handler to remove the function from
-			// handle:
-			//		the handle returned from add
-			if(node){
-				event = del._normalizeEventName(event);
-				if(!dojo.isIE && (event == "mouseenter" || event == "mouseleave")){
-					event = (event == "mouseenter") ? "mouseover" : "mouseout";
-				}
-
-				node.removeEventListener(event, handle, false);
-			}
-		},
-		_normalizeEventName: function(/*String*/ name){
-			// Generally, name should be lower case, unless it is special
-			// somehow (e.g. a Mozilla DOM event).
-			// Remove 'on'.
-			return name.slice(0,2) =="on" ? name.slice(2) : name;
-		},
-		_fixCallback: function(/*String*/ name, fp){
-			// By default, we only invoke _fixEvent for 'keypress'
-			// If code is added to _fixEvent for other events, we have
-			// to revisit this optimization.
-			// This also applies to _fixEvent overrides for Safari and Opera
-			// below.
-			return name != "keypress" ? fp : function(e){ return fp.call(this, del._fixEvent(e, this)); };
-		},
-		_fixEvent: function(evt, sender){
-			// _fixCallback only attaches us to keypress.
-			// Switch on evt.type anyway because we might
-			// be called directly from dojo.fixEvent.
-			switch(evt.type){
-				case "keypress":
-					del._setKeyChar(evt);
-					break;
-			}
-			return evt;
-		},
-		_setKeyChar: function(evt){
-			evt.keyChar = evt.charCode >= 32 ? String.fromCharCode(evt.charCode) : '';
-			evt.charOrCode = evt.keyChar || evt.keyCode;
-		},
-		// For IE and Safari: some ctrl-key combinations (mostly w/punctuation) do not emit a char code in IE
-		// we map those virtual key codes to ascii here
-		// not valid for all (non-US) keyboards, so maybe we shouldn't bother
-		_punctMap: {
-			106:42,
-			111:47,
-			186:59,
-			187:43,
-			188:44,
-			189:45,
-			190:46,
-			191:47,
-			192:96,
-			219:91,
-			220:92,
-			221:93,
-			222:39
-		}
-	});
-
-	// DOM events
-	
-	dojo.fixEvent = function(/*Event*/ evt, /*DOMNode*/ sender){
-		// summary:
-		//		normalizes properties on the event object including event
-		//		bubbling methods, keystroke normalization, and x/y positions
-		// evt: Event
-		//		native event object
-		// sender: DOMNode
-		//		node to treat as "currentTarget"
-		return del._fixEvent(evt, sender);
-	};
-
-	dojo.stopEvent = function(/*Event*/ evt){
-		// summary:
-		//		prevents propagation and clobbers the default action of the
-		//		passed event
-		// evt: Event
-		//		The event object. If omitted, window.event is used on IE.
-		evt.preventDefault();
-		evt.stopPropagation();
-		// NOTE: below, this method is overridden for IE
-	};
-
-	// the default listener to use on dontFix nodes, overriden for IE
-	var node_listener = dojo._listener;
-	
-	// Unify connect and event listeners
-	dojo._connect = function(obj, event, context, method, dontFix){
-		// FIXME: need a more strict test
-		var isNode = obj && (obj.nodeType||obj.attachEvent||obj.addEventListener);
-		// choose one of three listener options: raw (connect.js), DOM event on a Node, custom event on a Node
-		// we need the third option to provide leak prevention on broken browsers (IE)
-		var lid = isNode ? (dontFix ? 2 : 1) : 0, l = [dojo._listener, del, node_listener][lid];
-		// create a listener
-		var h = l.add(obj, event, dojo.hitch(context, method));
-		// formerly, the disconnect package contained "l" directly, but if client code
-		// leaks the disconnect package (by connecting it to a node), referencing "l"
-		// compounds the problem.
-		// instead we return a listener id, which requires custom _disconnect below.
-		// return disconnect package
-		return [ obj, event, h, lid ];
-	};
-
-	dojo._disconnect = function(obj, event, handle, listener){
-		([dojo._listener, del, node_listener][listener]).remove(obj, event, handle);
-	};
-
-	// Constants
-
-	// Public: client code should test
-	// keyCode against these named constants, as the
-	// actual codes can vary by browser.
-	dojo.keys = {
-		// summary:
-		//		Definitions for common key values
-		BACKSPACE: 8,
-		TAB: 9,
-		CLEAR: 12,
-		ENTER: 13,
-		SHIFT: 16,
-		CTRL: 17,
-		ALT: 18,
-		META: dojo.isSafari ? 91 : 224,		// the apple key on macs
-		PAUSE: 19,
-		CAPS_LOCK: 20,
-		ESCAPE: 27,
-		SPACE: 32,
-		PAGE_UP: 33,
-		PAGE_DOWN: 34,
-		END: 35,
-		HOME: 36,
-		LEFT_ARROW: 37,
-		UP_ARROW: 38,
-		RIGHT_ARROW: 39,
-		DOWN_ARROW: 40,
-		INSERT: 45,
-		DELETE: 46,
-		HELP: 47,
-		LEFT_WINDOW: 91,
-		RIGHT_WINDOW: 92,
-		SELECT: 93,
-		NUMPAD_0: 96,
-		NUMPAD_1: 97,
-		NUMPAD_2: 98,
-		NUMPAD_3: 99,
-		NUMPAD_4: 100,
-		NUMPAD_5: 101,
-		NUMPAD_6: 102,
-		NUMPAD_7: 103,
-		NUMPAD_8: 104,
-		NUMPAD_9: 105,
-		NUMPAD_MULTIPLY: 106,
-		NUMPAD_PLUS: 107,
-		NUMPAD_ENTER: 108,
-		NUMPAD_MINUS: 109,
-		NUMPAD_PERIOD: 110,
-		NUMPAD_DIVIDE: 111,
-		F1: 112,
-		F2: 113,
-		F3: 114,
-		F4: 115,
-		F5: 116,
-		F6: 117,
-		F7: 118,
-		F8: 119,
-		F9: 120,
-		F10: 121,
-		F11: 122,
-		F12: 123,
-		F13: 124,
-		F14: 125,
-		F15: 126,
-		NUM_LOCK: 144,
-		SCROLL_LOCK: 145,
-		// virtual key mapping
-		copyKey: dojo.isMac && !dojo.isAIR ? (dojo.isSafari ? 91 : 224 ) : 17
-	};
-	
-	var evtCopyKey = dojo.isMac ? "metaKey" : "ctrlKey";
-	
-	dojo.isCopyKey = function(e){
-		// summary:
-		//		Checks an event for the copy key (meta on Mac, and ctrl anywhere else)
-		// e: Event
-		//		Event object to examine
-		return e[evtCopyKey];	// Boolean
-	};
-
-	// Public: decoding mouse buttons from events
-
-/*=====
-	dojo.mouseButtons = {
-		// LEFT: Number
-		//		Numeric value of the left mouse button for the platform.
-		LEFT:   0,
-		// MIDDLE: Number
-		//		Numeric value of the middle mouse button for the platform.
-		MIDDLE: 1,
-		// RIGHT: Number
-		//		Numeric value of the right mouse button for the platform.
-		RIGHT:  2,
-	
-		isButton: function(e, button){
-			// summary:
-			//		Checks an event object for a pressed button
-			// e: Event
-			//		Event object to examine
-			// button: Number
-			//		The button value (example: dojo.mouseButton.LEFT)
-			return e.button == button; // Boolean
-		},
-		isLeft: function(e){
-			// summary:
-			//		Checks an event object for the pressed left button
-			// e: Event
-			//		Event object to examine
-			return e.button == 0; // Boolean
-		},
-		isMiddle: function(e){
-			// summary:
-			//		Checks an event object for the pressed middle button
-			// e: Event
-			//		Event object to examine
-			return e.button == 1; // Boolean
-		},
-		isRight: function(e){
-			// summary:
-			//		Checks an event object for the pressed right button
-			// e: Event
-			//		Event object to examine
-			return e.button == 2; // Boolean
-		}
-	};
-=====*/
-
-		if(dojo.isIE < 9 || (dojo.isIE && dojo.isQuirks)){
-		dojo.mouseButtons = {
-			LEFT:   1,
-			MIDDLE: 4,
-			RIGHT:  2,
-			// helper functions
-			isButton: function(e, button){ return e.button & button; },
-			isLeft:   function(e){ return e.button & 1; },
-			isMiddle: function(e){ return e.button & 4; },
-			isRight:  function(e){ return e.button & 2; }
-		};
-	}else{
-			dojo.mouseButtons = {
-			LEFT:   0,
-			MIDDLE: 1,
-			RIGHT:  2,
-			// helper functions
-			isButton: function(e, button){ return e.button == button; },
-			isLeft:   function(e){ return e.button == 0; },
-			isMiddle: function(e){ return e.button == 1; },
-			isRight:  function(e){ return e.button == 2; }
-		};
-		}
-	
-		// IE event normalization
-	if(dojo.isIE){
-		var _trySetKeyCode = function(e, code){
-			try{
-				// squelch errors when keyCode is read-only
-				// (e.g. if keyCode is ctrl or shift)
-				return (e.keyCode = code);
-			}catch(e){
-				return 0;
-			}
-		};
-
-		// by default, use the standard listener
-		var iel = dojo._listener;
-		var listenersName = (dojo._ieListenersName = "_" + dojo._scopeName + "_listeners");
-		// dispatcher tracking property
-		if(!dojo.config._allow_leaks){
-			// custom listener that handles leak protection for DOM events
-			node_listener = iel = dojo._ie_listener = {
-				// support handler indirection: event handler functions are
-				// referenced here. Event dispatchers hold only indices.
-				handlers: [],
-				// add a listener to an object
-				add: function(/*Object*/ source, /*String*/ method, /*Function*/ listener){
-					source = source || dojo.global;
-					var f = source[method];
-					if(!f||!f[listenersName]){
-						var d = dojo._getIeDispatcher();
-						// original target function is special
-						d.target = f && (ieh.push(f) - 1);
-						// dispatcher holds a list of indices into handlers table
-						d[listenersName] = [];
-						// redirect source to dispatcher
-						f = source[method] = d;
-					}
-					return f[listenersName].push(ieh.push(listener) - 1) ; /*Handle*/
-				},
-				// remove a listener from an object
-				remove: function(/*Object*/ source, /*String*/ method, /*Handle*/ handle){
-					var f = (source||dojo.global)[method], l = f && f[listenersName];
-					if(f && l && handle--){
-						delete ieh[l[handle]];
-						delete l[handle];
-					}
-				}
-			};
-			// alias used above
-			var ieh = iel.handlers;
-		}
-
-		dojo.mixin(del, {
-			add: function(/*DOMNode*/ node, /*String*/ event, /*Function*/ fp){
-				if(!node){return;} // undefined
-				event = del._normalizeEventName(event);
-				if(event=="onkeypress"){
-					// we need to listen to onkeydown to synthesize
-					// keypress events that otherwise won't fire
-					// on IE
-					var kd = node.onkeydown;
-					if(!kd || !kd[listenersName] || !kd._stealthKeydownHandle){
-						var h = del.add(node, "onkeydown", del._stealthKeyDown);
-						kd = node.onkeydown;
-						kd._stealthKeydownHandle = h;
-						kd._stealthKeydownRefs = 1;
-					}else{
-						kd._stealthKeydownRefs++;
-					}
-				}
-				return iel.add(node, event, del._fixCallback(fp));
-			},
-			remove: function(/*DOMNode*/ node, /*String*/ event, /*Handle*/ handle){
-				event = del._normalizeEventName(event);
-				iel.remove(node, event, handle);
-				if(event=="onkeypress"){
-					var kd = node.onkeydown;
-					if(--kd._stealthKeydownRefs <= 0){
-						iel.remove(node, "onkeydown", kd._stealthKeydownHandle);
-						delete kd._stealthKeydownHandle;
-					}
-				}
-			},
-			_normalizeEventName: function(/*String*/ eventName){
-				// Generally, eventName should be lower case, unless it is
-				// special somehow (e.g. a Mozilla event)
-				// ensure 'on'
-				return eventName.slice(0,2) != "on" ? "on" + eventName : eventName;
-			},
-			_nop: function(){},
-			_fixEvent: function(/*Event*/ evt, /*DOMNode*/ sender){
-				// summary:
-				//		normalizes properties on the event object including event
-				//		bubbling methods, keystroke normalization, and x/y positions
-				// evt:
-				//		native event object
-				// sender:
-				//		node to treat as "currentTarget"
-				if(!evt){
-					var w = sender && (sender.ownerDocument || sender.document || sender).parentWindow || window;
-					evt = w.event;
-				}
-				if(!evt){return(evt);}
-				evt.target = evt.srcElement;
-				evt.currentTarget = (sender || evt.srcElement);
-				evt.layerX = evt.offsetX;
-				evt.layerY = evt.offsetY;
-				// FIXME: scroll position query is duped from dojo.html to
-				// avoid dependency on that entire module. Now that HTML is in
-				// Base, we should convert back to something similar there.
-				var se = evt.srcElement, doc = (se && se.ownerDocument) || document;
-				// DO NOT replace the following to use dojo.body(), in IE, document.documentElement should be used
-				// here rather than document.body
-				var docBody = ((dojo.isIE < 6) || (doc["compatMode"] == "BackCompat")) ? doc.body : doc.documentElement;
-				var offset = dojo._getIeDocumentElementOffset();
-				evt.pageX = evt.clientX + dojo._fixIeBiDiScrollLeft(docBody.scrollLeft || 0) - offset.x;
-				evt.pageY = evt.clientY + (docBody.scrollTop || 0) - offset.y;
-				if(evt.type == "mouseover"){
-					evt.relatedTarget = evt.fromElement;
-				}
-				if(evt.type == "mouseout"){
-					evt.relatedTarget = evt.toElement;
-				}
-				if (dojo.isIE < 9 || dojo.isQuirks) {
-					evt.stopPropagation = del._stopPropagation;
-					evt.preventDefault = del._preventDefault;
-				}
-				return del._fixKeys(evt);
-			},
-			_fixKeys: function(evt){
-				switch(evt.type){
-					case "keypress":
-						var c = ("charCode" in evt ? evt.charCode : evt.keyCode);
-						if (c==10){
-							// CTRL-ENTER is CTRL-ASCII(10) on IE, but CTRL-ENTER on Mozilla
-							c=0;
-							evt.keyCode = 13;
-						}else if(c==13||c==27){
-							c=0; // Mozilla considers ENTER and ESC non-printable
-						}else if(c==3){
-							c=99; // Mozilla maps CTRL-BREAK to CTRL-c
-						}
-						// Mozilla sets keyCode to 0 when there is a charCode
-						// but that stops the event on IE.
-						evt.charCode = c;
-						del._setKeyChar(evt);
-						break;
-				}
-				return evt;
-			},
-			_stealthKeyDown: function(evt){
-				// IE doesn't fire keypress for most non-printable characters.
-				// other browsers do, we simulate it here.
-				var kp = evt.currentTarget.onkeypress;
-				// only works if kp exists and is a dispatcher
-				if(!kp || !kp[listenersName]){ return; }
-				// munge key/charCode
-				var k=evt.keyCode;
-				// These are Windows Virtual Key Codes
-				// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/WinUI/WindowsUserInterface/UserInput/VirtualKeyCodes.asp
-				var unprintable = (k!=13 || (dojo.isIE >= 9 && !dojo.isQuirks)) && k!=32 && k!=27 && (k<48||k>90) && (k<96||k>111) && (k<186||k>192) && (k<219||k>222);
-
-				// synthesize keypress for most unprintables and CTRL-keys
-				if(unprintable||evt.ctrlKey){
-					var c = unprintable ? 0 : k;
-					if(evt.ctrlKey){
-						if(k==3 || k==13){
-							return; // IE will post CTRL-BREAK, CTRL-ENTER as keypress natively
-						}else if(c>95 && c<106){
-							c -= 48; // map CTRL-[numpad 0-9] to ASCII
-						}else if((!evt.shiftKey)&&(c>=65&&c<=90)){
-							c += 32; // map CTRL-[A-Z] to lowercase
-						}else{
-							c = del._punctMap[c] || c; // map other problematic CTRL combinations to ASCII
-						}
-					}
-					// simulate a keypress event
-					var faux = del._synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c});
-					kp.call(evt.currentTarget, faux);
-					if(dojo.isIE < 9 || (dojo.isIE && dojo.isQuirks)){
-						evt.cancelBubble = faux.cancelBubble;
-					}
-					evt.returnValue = faux.returnValue;
-					_trySetKeyCode(evt, faux.keyCode);
-				}
-			},
-			// Called in Event scope
-			_stopPropagation: function(){
-				this.cancelBubble = true;
-			},
-			_preventDefault: function(){
-				// Setting keyCode to 0 is the only way to prevent certain keypresses (namely
-				// ctrl-combinations that correspond to menu accelerator keys).
-				// Otoh, it prevents upstream listeners from getting this information
-				// Try to split the difference here by clobbering keyCode only for ctrl
-				// combinations. If you still need to access the key upstream, bubbledKeyCode is
-				// provided as a workaround.
-				this.bubbledKeyCode = this.keyCode;
-				if(this.ctrlKey){_trySetKeyCode(this, 0);}
-				this.returnValue = false;
-			}
-		});
-				
-		// override stopEvent for IE
-		dojo.stopEvent = (dojo.isIE < 9 || dojo.isQuirks) ? function(evt){
-			evt = evt || window.event;
-			del._stopPropagation.call(evt);
-			del._preventDefault.call(evt);
-		} : dojo.stopEvent;
-	}
-	
-	del._synthesizeEvent = function(evt, props){
-			var faux = dojo.mixin({}, evt, props);
-			del._setKeyChar(faux);
-			// FIXME: would prefer to use dojo.hitch: dojo.hitch(evt, evt.preventDefault);
-			// but it throws an error when preventDefault is invoked on Safari
-			// does Event.preventDefault not support "apply" on Safari?
-			faux.preventDefault = function(){ evt.preventDefault(); };
-			faux.stopPropagation = function(){ evt.stopPropagation(); };
-			return faux;
-	};
-	
-		// Opera event normalization
-	if(dojo.isOpera){
-		dojo.mixin(del, {
-			_fixEvent: function(evt, sender){
-				switch(evt.type){
-					case "keypress":
-						var c = evt.which;
-						if(c==3){
-							c=99; // Mozilla maps CTRL-BREAK to CTRL-c
-						}
-						// can't trap some keys at all, like INSERT and DELETE
-						// there is no differentiating info between DELETE and ".", or INSERT and "-"
-						c = c<41 && !evt.shiftKey ? 0 : c;
-						if(evt.ctrlKey && !evt.shiftKey && c>=65 && c<=90){
-							// lowercase CTRL-[A-Z] keys
-							c += 32;
-						}
-						return del._synthesizeEvent(evt, { charCode: c });
-				}
-				return evt;
-			}
-		});
-	}
-	
-		// Webkit event normalization
-	if(dojo.isWebKit){
-				del._add = del.add;
-		del._remove = del.remove;
-
-		dojo.mixin(del, {
-			add: function(/*DOMNode*/ node, /*String*/ event, /*Function*/ fp){
-				if(!node){return;} // undefined
-				var handle = del._add(node, event, fp);
-				if(del._normalizeEventName(event) == "keypress"){
-					// we need to listen to onkeydown to synthesize
-					// keypress events that otherwise won't fire
-					// in Safari 3.1+: https://lists.webkit.org/pipermail/webkit-dev/2007-December/002992.html
-					handle._stealthKeyDownHandle = del._add(node, "keydown", function(evt){
-						//A variation on the IE _stealthKeydown function
-						//Synthesize an onkeypress event, but only for unprintable characters.
-						var k=evt.keyCode;
-						// These are Windows Virtual Key Codes
-						// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/WinUI/WindowsUserInterface/UserInput/VirtualKeyCodes.asp
-						var unprintable = k!=13 && k!=32 && (k<48 || k>90) && (k<96 || k>111) && (k<186 || k>192) && (k<219 || k>222);
-						// synthesize keypress for most unprintables and CTRL-keys
-						if(unprintable || evt.ctrlKey){
-							var c = unprintable ? 0 : k;
-							if(evt.ctrlKey){
-								if(k==3 || k==13){
-									return; // IE will post CTRL-BREAK, CTRL-ENTER as keypress natively
-								}else if(c>95 && c<106){
-									c -= 48; // map CTRL-[numpad 0-9] to ASCII
-								}else if(!evt.shiftKey && c>=65 && c<=90){
-									c += 32; // map CTRL-[A-Z] to lowercase
-								}else{
-									c = del._punctMap[c] || c; // map other problematic CTRL combinations to ASCII
-								}
-							}
-							// simulate a keypress event
-							var faux = del._synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c});
-							fp.call(evt.currentTarget, faux);
-						}
-					});
-				}
-				return handle; /*Handle*/
-			},
-
-			remove: function(/*DOMNode*/ node, /*String*/ event, /*Handle*/ handle){
-				if(node){
-					if(handle._stealthKeyDownHandle){
-						del._remove(node, "keydown", handle._stealthKeyDownHandle);
-					}
-					del._remove(node, event, handle);
-				}
-			},
-			_fixEvent: function(evt, sender){
-				switch(evt.type){
-					case "keypress":
-						if(evt.faux){ return evt; }
-						var c = evt.charCode;
-						c = c>=32 ? c : 0;
-						return del._synthesizeEvent(evt, {charCode: c, faux: true});
-				}
-				return evt;
-			}
-		});
-		}
-	})();
-
-if(dojo.isIE){
-	// keep this out of the closure
-	// closing over 'iel' or 'ieh' b0rks leak prevention
-	// ls[i] is an index into the master handler array
-	dojo._ieDispatcher = function(args, sender){
-		var ap = Array.prototype,
-			h = dojo._ie_listener.handlers,
-			c = args.callee,
-			ls = c[dojo._ieListenersName],
-			t = h[c.target];
-		// return value comes from original target function
-		var r = t && t.apply(sender, args);
-		// make local copy of listener array so it's immutable during processing
-		var lls = [].concat(ls);
-		// invoke listeners after target function
-		for(var i in lls){
-			var f = h[lls[i]];
-			if(!(i in ap) && f){
-				f.apply(sender, args);
-			}
-		}
-		return r;
-	};
-	dojo._getIeDispatcher = function(){
-		// ensure the returned function closes over nothing ("new Function" apparently doesn't close)
-		return new Function(dojo._scopeName + "._ieDispatcher(arguments, this)"); // function
-	};
-	// keep this out of the closure to reduce RAM allocation
-	dojo._event_listener._fixCallback = function(fp){
-		var f = dojo._event_listener._fixEvent;
-		return function(e){ return fp.call(this, f(e, this)); };
-	};
-}
-
-}
+//>>built
+define("dojo/_base/event",["./kernel","../on","../has","../dom-geometry"],function(_1,on,_2,_3){if(on._fixEvent){var _4=on._fixEvent;on._fixEvent=function(_5,se){_5=_4(_5,se);if(_5){_3.normalizeEvent(_5);}return _5;};}_1.fixEvent=function(_6,_7){if(on._fixEvent){return on._fixEvent(_6,_7);}return _6;};_1.stopEvent=function(_8){if(_2("dom-addeventlistener")||(_8&&_8.preventDefault)){_8.preventDefault();_8.stopPropagation();}else{_8=_8||window.event;_8.cancelBubble=true;on._preventDefault.call(_8);}};return {fix:_1.fixEvent,stop:_1.stopEvent};});
\ No newline at end of file
diff --git a/lib/dojo/_base/event.js.uncompressed.js b/lib/dojo/_base/event.js.uncompressed.js
new file mode 100644
index 000000000..34b9ce8e6
--- /dev/null
+++ b/lib/dojo/_base/event.js.uncompressed.js
@@ -0,0 +1,51 @@
+define("dojo/_base/event", ["./kernel", "../on", "../has", "../dom-geometry"], function(dojo, on, has, dom){
+  //  module:
+  //    dojo/_base/event
+  //  summary:
+  //    This module defines dojo DOM event API.
+	if(on._fixEvent){
+		var fixEvent = on._fixEvent;
+		on._fixEvent = function(evt, se){
+			// add some additional normalization for back-compat, this isn't in on.js because it is somewhat more expensive
+			evt = fixEvent(evt, se);
+			if(evt){
+				dom.normalizeEvent(evt);
+			}
+			return evt;
+		};		
+	}
+	dojo.fixEvent = function(/*Event*/ evt, /*DOMNode*/ sender){
+		// summary:
+		//		normalizes properties on the event object including event
+		//		bubbling methods, keystroke normalization, and x/y positions
+		// evt: Event
+		//		native event object
+		// sender: DOMNode
+		//		node to treat as "currentTarget"
+		if(on._fixEvent){
+			return on._fixEvent(evt, sender);
+		}
+		return evt;	// Event
+	};
+	
+	dojo.stopEvent = function(/*Event*/ evt){
+		// summary:
+		//		prevents propagation and clobbers the default action of the
+		//		passed event
+		// evt: Event
+		//		The event object. If omitted, window.event is used on IE.
+		if(has("dom-addeventlistener") || (evt && evt.preventDefault)){
+			evt.preventDefault();
+			evt.stopPropagation();
+		}else{
+			evt = evt || window.event;
+			evt.cancelBubble = true;
+			on._preventDefault.call(evt);
+		}
+	};
+
+	return {
+		fix: dojo.fixEvent,
+		stop: dojo.stopEvent
+	};
+});
diff --git a/lib/dojo/_base/fx.js b/lib/dojo/_base/fx.js
index 860e0e18b..0ac96bc69 100644
--- a/lib/dojo/_base/fx.js
+++ b/lib/dojo/_base/fx.js
@@ -4,667 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.fx"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.fx"] = true;
-dojo.provide("dojo._base.fx");
-dojo.require("dojo._base.Color");
-dojo.require("dojo._base.connect");
-dojo.require("dojo._base.lang");
-dojo.require("dojo._base.html");
-
-
-/*
-	Animation loosely package based on Dan Pupius' work, contributed under CLA:
-		http://pupius.co.uk/js/Toolkit.Drawing.js
-*/
-(function(){
-	var d = dojo;
-	var _mixin = d._mixin;
-
-	dojo._Line = function(/*int*/ start, /*int*/ end){
-		//	summary:
-		//		dojo._Line is the object used to generate values from a start value
-		//		to an end value
-		//	start: int
-		//		Beginning value for range
-		//	end: int
-		//		Ending value for range
-		this.start = start;
-		this.end = end;
-	};
-
-	dojo._Line.prototype.getValue = function(/*float*/ n){
-		//	summary: Returns the point on the line
-		//	n: a floating point number greater than 0 and less than 1
-		return ((this.end - this.start) * n) + this.start; // Decimal
-	};
-
-	dojo.Animation = function(args){
-		//	summary:
-		//		A generic animation class that fires callbacks into its handlers
-		//		object at various states.
-		//	description:
-		//		A generic animation class that fires callbacks into its handlers
-		//		object at various states. Nearly all dojo animation functions
-		//		return an instance of this method, usually without calling the
-		//		.play() method beforehand. Therefore, you will likely need to
-		//		call .play() on instances of `dojo.Animation` when one is
-		//		returned.
-		// args: Object
-		//		The 'magic argument', mixing all the properties into this
-		//		animation instance.
-
-		_mixin(this, args);
-		if(d.isArray(this.curve)){
-			this.curve = new d._Line(this.curve[0], this.curve[1]);
-		}
-
-	};
-
-	// Alias to drop come 2.0:
-	d._Animation = d.Animation;
-
-	d.extend(dojo.Animation, {
-		// duration: Integer
-		//		The time in milliseonds the animation will take to run
-		duration: 350,
-
-	/*=====
-		// curve: dojo._Line|Array
-		//		A two element array of start and end values, or a `dojo._Line` instance to be
-		//		used in the Animation.
-		curve: null,
-
-		// easing: Function?
-		//		A Function to adjust the acceleration (or deceleration) of the progress
-		//		across a dojo._Line
-		easing: null,
-	=====*/
-
-		// repeat: Integer?
-		//		The number of times to loop the animation
-		repeat: 0,
-
-		// rate: Integer?
-		//		the time in milliseconds to wait before advancing to next frame
-		//		(used as a fps timer: 1000/rate = fps)
-		rate: 20 /* 50 fps */,
-
-	/*=====
-		// delay: Integer?
-		//		The time in milliseconds to wait before starting animation after it
-		//		has been .play()'ed
-		delay: null,
-
-		// beforeBegin: Event?
-		//		Synthetic event fired before a dojo.Animation begins playing (synchronous)
-		beforeBegin: null,
-
-		// onBegin: Event?
-		//		Synthetic event fired as a dojo.Animation begins playing (useful?)
-		onBegin: null,
-
-		// onAnimate: Event?
-		//		Synthetic event fired at each interval of a `dojo.Animation`
-		onAnimate: null,
-
-		// onEnd: Event?
-		//		Synthetic event fired after the final frame of a `dojo.Animation`
-		onEnd: null,
-
-		// onPlay: Event?
-		//		Synthetic event fired any time a `dojo.Animation` is play()'ed
-		onPlay: null,
-
-		// onPause: Event?
-		//		Synthetic event fired when a `dojo.Animation` is paused
-		onPause: null,
-
-		// onStop: Event
-		//		Synthetic event fires when a `dojo.Animation` is stopped
-		onStop: null,
-
-	=====*/
-
-		_percent: 0,
-		_startRepeatCount: 0,
-
-		_getStep: function(){
-			var _p = this._percent,
-				_e = this.easing
-			;
-			return _e ? _e(_p) : _p;
-		},
-		_fire: function(/*Event*/ evt, /*Array?*/ args){
-			//	summary:
-			//		Convenience function.  Fire event "evt" and pass it the
-			//		arguments specified in "args".
-			//	description:
-			//		Convenience function.  Fire event "evt" and pass it the
-			//		arguments specified in "args".
-			//		Fires the callback in the scope of the `dojo.Animation`
-			//		instance.
-			//	evt:
-			//		The event to fire.
-			//	args:
-			//		The arguments to pass to the event.
-			var a = args||[];
-			if(this[evt]){
-				if(d.config.debugAtAllCosts){
-					this[evt].apply(this, a);
-				}else{
-					try{
-						this[evt].apply(this, a);
-					}catch(e){
-						// squelch and log because we shouldn't allow exceptions in
-						// synthetic event handlers to cause the internal timer to run
-						// amuck, potentially pegging the CPU. I'm not a fan of this
-						// squelch, but hopefully logging will make it clear what's
-						// going on
-						console.error("exception in animation handler for:", evt);
-						console.error(e);
-					}
-				}
-			}
-			return this; // dojo.Animation
-		},
-
-		play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
-			// summary:
-			//		Start the animation.
-			// delay:
-			//		How many milliseconds to delay before starting.
-			// gotoStart:
-			//		If true, starts the animation from the beginning; otherwise,
-			//		starts it from its current position.
-			// returns: dojo.Animation
-			//		The instance to allow chaining.
-
-			var _t = this;
-			if(_t._delayTimer){ _t._clearTimer(); }
-			if(gotoStart){
-				_t._stopTimer();
-				_t._active = _t._paused = false;
-				_t._percent = 0;
-			}else if(_t._active && !_t._paused){
-				return _t;
-			}
-
-			_t._fire("beforeBegin", [_t.node]);
-
-			var de = delay || _t.delay,
-				_p = dojo.hitch(_t, "_play", gotoStart);
-
-			if(de > 0){
-				_t._delayTimer = setTimeout(_p, de);
-				return _t;
-			}
-			_p();
-			return _t;
-		},
-
-		_play: function(gotoStart){
-			var _t = this;
-			if(_t._delayTimer){ _t._clearTimer(); }
-			_t._startTime = new Date().valueOf();
-			if(_t._paused){
-				_t._startTime -= _t.duration * _t._percent;
-			}
-
-			_t._active = true;
-			_t._paused = false;
-			var value = _t.curve.getValue(_t._getStep());
-			if(!_t._percent){
-				if(!_t._startRepeatCount){
-					_t._startRepeatCount = _t.repeat;
-				}
-				_t._fire("onBegin", [value]);
-			}
-
-			_t._fire("onPlay", [value]);
-
-			_t._cycle();
-			return _t; // dojo.Animation
-		},
-
-		pause: function(){
-			// summary: Pauses a running animation.
-			var _t = this;
-			if(_t._delayTimer){ _t._clearTimer(); }
-			_t._stopTimer();
-			if(!_t._active){ return _t; /*dojo.Animation*/ }
-			_t._paused = true;
-			_t._fire("onPause", [_t.curve.getValue(_t._getStep())]);
-			return _t; // dojo.Animation
-		},
-
-		gotoPercent: function(/*Decimal*/ percent, /*Boolean?*/ andPlay){
-			//	summary:
-			//		Sets the progress of the animation.
-			//	percent:
-			//		A percentage in decimal notation (between and including 0.0 and 1.0).
-			//	andPlay:
-			//		If true, play the animation after setting the progress.
-			var _t = this;
-			_t._stopTimer();
-			_t._active = _t._paused = true;
-			_t._percent = percent;
-			if(andPlay){ _t.play(); }
-			return _t; // dojo.Animation
-		},
-
-		stop: function(/*boolean?*/ gotoEnd){
-			// summary: Stops a running animation.
-			// gotoEnd: If true, the animation will end.
-			var _t = this;
-			if(_t._delayTimer){ _t._clearTimer(); }
-			if(!_t._timer){ return _t; /* dojo.Animation */ }
-			_t._stopTimer();
-			if(gotoEnd){
-				_t._percent = 1;
-			}
-			_t._fire("onStop", [_t.curve.getValue(_t._getStep())]);
-			_t._active = _t._paused = false;
-			return _t; // dojo.Animation
-		},
-
-		status: function(){
-			// summary:
-			//		Returns a string token representation of the status of
-			//		the animation, one of: "paused", "playing", "stopped"
-			if(this._active){
-				return this._paused ? "paused" : "playing"; // String
-			}
-			return "stopped"; // String
-		},
-
-		_cycle: function(){
-			var _t = this;
-			if(_t._active){
-				var curr = new Date().valueOf();
-				var step = (curr - _t._startTime) / (_t.duration);
-
-				if(step >= 1){
-					step = 1;
-				}
-				_t._percent = step;
-
-				// Perform easing
-				if(_t.easing){
-					step = _t.easing(step);
-				}
-
-				_t._fire("onAnimate", [_t.curve.getValue(step)]);
-
-				if(_t._percent < 1){
-					_t._startTimer();
-				}else{
-					_t._active = false;
-
-					if(_t.repeat > 0){
-						_t.repeat--;
-						_t.play(null, true);
-					}else if(_t.repeat == -1){
-						_t.play(null, true);
-					}else{
-						if(_t._startRepeatCount){
-							_t.repeat = _t._startRepeatCount;
-							_t._startRepeatCount = 0;
-						}
-					}
-					_t._percent = 0;
-					_t._fire("onEnd", [_t.node]);
-					!_t.repeat && _t._stopTimer();
-				}
-			}
-			return _t; // dojo.Animation
-		},
-
-		_clearTimer: function(){
-			// summary: Clear the play delay timer
-			clearTimeout(this._delayTimer);
-			delete this._delayTimer;
-		}
-
-	});
-
-	// the local timer, stubbed into all Animation instances
-	var ctr = 0,
-		timer = null,
-		runner = {
-			run: function(){}
-		};
-
-	d.extend(d.Animation, {
-
-		_startTimer: function(){
-			if(!this._timer){
-				this._timer = d.connect(runner, "run", this, "_cycle");
-				ctr++;
-			}
-			if(!timer){
-				timer = setInterval(d.hitch(runner, "run"), this.rate);
-			}
-		},
-
-		_stopTimer: function(){
-			if(this._timer){
-				d.disconnect(this._timer);
-				this._timer = null;
-				ctr--;
-			}
-			if(ctr <= 0){
-				clearInterval(timer);
-				timer = null;
-				ctr = 0;
-			}
-		}
-
-	});
-
-	var _makeFadeable =
-				d.isIE ? function(node){
-			// only set the zoom if the "tickle" value would be the same as the
-			// default
-			var ns = node.style;
-			// don't set the width to auto if it didn't already cascade that way.
-			// We don't want to f anyones designs
-			if(!ns.width.length && d.style(node, "width") == "auto"){
-				ns.width = "auto";
-			}
-		} :
-				function(){};
-
-	dojo._fade = function(/*Object*/ args){
-		//	summary:
-		//		Returns an animation that will fade the node defined by
-		//		args.node from the start to end values passed (args.start
-		//		args.end) (end is mandatory, start is optional)
-
-		args.node = d.byId(args.node);
-		var fArgs = _mixin({ properties: {} }, args),
-			props = (fArgs.properties.opacity = {});
-
-		props.start = !("start" in fArgs) ?
-			function(){
-				return +d.style(fArgs.node, "opacity")||0;
-			} : fArgs.start;
-		props.end = fArgs.end;
-
-		var anim = d.animateProperty(fArgs);
-		d.connect(anim, "beforeBegin", d.partial(_makeFadeable, fArgs.node));
-
-		return anim; // dojo.Animation
-	};
-
-	/*=====
-	dojo.__FadeArgs = function(node, duration, easing){
-		//	node: DOMNode|String
-		//		The node referenced in the animation
-		//	duration: Integer?
-		//		Duration of the animation in milliseconds.
-		//	easing: Function?
-		//		An easing function.
-		this.node = node;
-		this.duration = duration;
-		this.easing = easing;
-	}
-	=====*/
-
-	dojo.fadeIn = function(/*dojo.__FadeArgs*/ args){
-		// summary:
-		//		Returns an animation that will fade node defined in 'args' from
-		//		its current opacity to fully opaque.
-		return d._fade(_mixin({ end: 1 }, args)); // dojo.Animation
-	};
-
-	dojo.fadeOut = function(/*dojo.__FadeArgs*/  args){
-		// summary:
-		//		Returns an animation that will fade node defined in 'args'
-		//		from its current opacity to fully transparent.
-		return d._fade(_mixin({ end: 0 }, args)); // dojo.Animation
-	};
-
-	dojo._defaultEasing = function(/*Decimal?*/ n){
-		// summary: The default easing function for dojo.Animation(s)
-		return 0.5 + ((Math.sin((n + 1.5) * Math.PI)) / 2);
-	};
-
-	var PropLine = function(properties){
-		// PropLine is an internal class which is used to model the values of
-		// an a group of CSS properties across an animation lifecycle. In
-		// particular, the "getValue" function handles getting interpolated
-		// values between start and end for a particular CSS value.
-		this._properties = properties;
-		for(var p in properties){
-			var prop = properties[p];
-			if(prop.start instanceof d.Color){
-				// create a reusable temp color object to keep intermediate results
-				prop.tempColor = new d.Color();
-			}
-		}
-	};
-
-	PropLine.prototype.getValue = function(r){
-		var ret = {};
-		for(var p in this._properties){
-			var prop = this._properties[p],
-				start = prop.start;
-			if(start instanceof d.Color){
-				ret[p] = d.blendColors(start, prop.end, r, prop.tempColor).toCss();
-			}else if(!d.isArray(start)){
-				ret[p] = ((prop.end - start) * r) + start + (p != "opacity" ? prop.units || "px" : 0);
-			}
-		}
-		return ret;
-	};
-
-	/*=====
-	dojo.declare("dojo.__AnimArgs", [dojo.__FadeArgs], {
-		// Properties: Object?
-		//	A hash map of style properties to Objects describing the transition,
-		//	such as the properties of dojo._Line with an additional 'units' property
-		properties: {}
-
-		//TODOC: add event callbacks
-	});
-	=====*/
-
-	dojo.animateProperty = function(/*dojo.__AnimArgs*/ args){
-		// summary:
-		//		Returns an animation that will transition the properties of
-		//		node defined in `args` depending how they are defined in
-		//		`args.properties`
-		//
-		// description:
-		//		`dojo.animateProperty` is the foundation of most `dojo.fx`
-		//		animations. It takes an object of "properties" corresponding to
-		//		style properties, and animates them in parallel over a set
-		//		duration.
-		//
-		// example:
-		//		A simple animation that changes the width of the specified node.
-		//	|	dojo.animateProperty({
-		//	|		node: "nodeId",
-		//	|		properties: { width: 400 },
-		//	|	}).play();
-		//		Dojo figures out the start value for the width and converts the
-		//		integer specified for the width to the more expressive but
-		//		verbose form `{ width: { end: '400', units: 'px' } }` which you
-		//		can also specify directly. Defaults to 'px' if ommitted.
-		//
-		// example:
-		//		Animate width, height, and padding over 2 seconds... the
-		//		pedantic way:
-		//	|	dojo.animateProperty({ node: node, duration:2000,
-		//	|		properties: {
-		//	|			width: { start: '200', end: '400', units:"px" },
-		//	|			height: { start:'200', end: '400', units:"px" },
-		//	|			paddingTop: { start:'5', end:'50', units:"px" }
-		//	|		}
-		//	|	}).play();
-		//		Note 'paddingTop' is used over 'padding-top'. Multi-name CSS properties
-		//		are written using "mixed case", as the hyphen is illegal as an object key.
-		//
-		// example:
-		//		Plug in a different easing function and register a callback for
-		//		when the animation ends. Easing functions accept values between
-		//		zero and one and return a value on that basis. In this case, an
-		//		exponential-in curve.
-		//	|	dojo.animateProperty({
-		//	|		node: "nodeId",
-		//	|		// dojo figures out the start value
-		//	|		properties: { width: { end: 400 } },
-		//	|		easing: function(n){
-		//	|			return (n==0) ? 0 : Math.pow(2, 10 * (n - 1));
-		//	|		},
-		//	|		onEnd: function(node){
-		//	|			// called when the animation finishes. The animation
-		//	|			// target is passed to this function
-		//	|		}
-		//	|	}).play(500); // delay playing half a second
-		//
-		// example:
-		//		Like all `dojo.Animation`s, animateProperty returns a handle to the
-		//		Animation instance, which fires the events common to Dojo FX. Use `dojo.connect`
-		//		to access these events outside of the Animation definiton:
-		//	|	var anim = dojo.animateProperty({
-		//	|		node:"someId",
-		//	|		properties:{
-		//	|			width:400, height:500
-		//	|		}
-		//	|	});
-		//	|	dojo.connect(anim,"onEnd", function(){
-		//	|		console.log("animation ended");
-		//	|	});
-		//	|	// play the animation now:
-		//	|	anim.play();
-		//
-		// example:
-		//		Each property can be a function whose return value is substituted along.
-		//		Additionally, each measurement (eg: start, end) can be a function. The node
-		//		reference is passed direcly to callbacks.
-		//	|	dojo.animateProperty({
-		//	|		node:"mine",
-		//	|		properties:{
-		//	|			height:function(node){
-		//	|				// shrink this node by 50%
-		//	|				return dojo.position(node).h / 2
-		//	|			},
-		//	|			width:{
-		//	|				start:function(node){ return 100; },
-		//	|				end:function(node){ return 200; }
-		//	|			}
-		//	|		}
-		//	|	}).play();
-		//
-
-		var n = args.node = d.byId(args.node);
-		if(!args.easing){ args.easing = d._defaultEasing; }
-
-		var anim = new d.Animation(args);
-		d.connect(anim, "beforeBegin", anim, function(){
-			var pm = {};
-			for(var p in this.properties){
-				// Make shallow copy of properties into pm because we overwrite
-				// some values below. In particular if start/end are functions
-				// we don't want to overwrite them or the functions won't be
-				// called if the animation is reused.
-				if(p == "width" || p == "height"){
-					this.node.display = "block";
-				}
-				var prop = this.properties[p];
-				if(d.isFunction(prop)){
-					prop = prop(n);
-				}
-				prop = pm[p] = _mixin({}, (d.isObject(prop) ? prop: { end: prop }));
-
-				if(d.isFunction(prop.start)){
-					prop.start = prop.start(n);
-				}
-				if(d.isFunction(prop.end)){
-					prop.end = prop.end(n);
-				}
-				var isColor = (p.toLowerCase().indexOf("color") >= 0);
-				function getStyle(node, p){
-					// dojo.style(node, "height") can return "auto" or "" on IE; this is more reliable:
-					var v = { height: node.offsetHeight, width: node.offsetWidth }[p];
-					if(v !== undefined){ return v; }
-					v = d.style(node, p);
-					return (p == "opacity") ? +v : (isColor ? v : parseFloat(v));
-				}
-				if(!("end" in prop)){
-					prop.end = getStyle(n, p);
-				}else if(!("start" in prop)){
-					prop.start = getStyle(n, p);
-				}
-
-				if(isColor){
-					prop.start = new d.Color(prop.start);
-					prop.end = new d.Color(prop.end);
-				}else{
-					prop.start = (p == "opacity") ? +prop.start : parseFloat(prop.start);
-				}
-			}
-			this.curve = new PropLine(pm);
-		});
-		d.connect(anim, "onAnimate", d.hitch(d, "style", anim.node));
-		return anim; // dojo.Animation
-	};
-
-	dojo.anim = function(	/*DOMNode|String*/	node,
-							/*Object*/			properties,
-							/*Integer?*/		duration,
-							/*Function?*/		easing,
-							/*Function?*/		onEnd,
-							/*Integer?*/		delay){
-		//	summary:
-		//		A simpler interface to `dojo.animateProperty()`, also returns
-		//		an instance of `dojo.Animation` but begins the animation
-		//		immediately, unlike nearly every other Dojo animation API.
-		//	description:
-		//		`dojo.anim` is a simpler (but somewhat less powerful) version
-		//		of `dojo.animateProperty`.  It uses defaults for many basic properties
-		//		and allows for positional parameters to be used in place of the
-		//		packed "property bag" which is used for other Dojo animation
-		//		methods.
-		//
-		//		The `dojo.Animation` object returned from `dojo.anim` will be
-		//		already playing when it is returned from this function, so
-		//		calling play() on it again is (usually) a no-op.
-		//	node:
-		//		a DOM node or the id of a node to animate CSS properties on
-		//	duration:
-		//		The number of milliseconds over which the animation
-		//		should run. Defaults to the global animation default duration
-		//		(350ms).
-		//	easing:
-		//		An easing function over which to calculate acceleration
-		//		and deceleration of the animation through its duration.
-		//		A default easing algorithm is provided, but you may
-		//		plug in any you wish. A large selection of easing algorithms
-		//		are available in `dojo.fx.easing`.
-		//	onEnd:
-		//		A function to be called when the animation finishes
-		//		running.
-		//	delay:
-		//		The number of milliseconds to delay beginning the
-		//		animation by. The default is 0.
-		//	example:
-		//		Fade out a node
-		//	|	dojo.anim("id", { opacity: 0 });
-		//	example:
-		//		Fade out a node over a full second
-		//	|	dojo.anim("id", { opacity: 0 }, 1000);
-		return d.animateProperty({ // dojo.Animation
-			node: node,
-			duration: duration || d.Animation.prototype.duration,
-			properties: properties,
-			easing: easing,
-			onEnd: onEnd
-		}).play(delay || 0);
-	};
-})();
-
-}
+//>>built
+define("dojo/_base/fx",["./kernel","./lang","../Evented","./Color","./connect","./sniff","../dom","../dom-style"],function(_1,_2,_3,_4,_5,_6,_7,_8){var _9=_2.mixin;_1._Line=function(_a,_b){this.start=_a;this.end=_b;};_1._Line.prototype.getValue=function(n){return ((this.end-this.start)*n)+this.start;};_1.Animation=function(_c){_9(this,_c);if(_2.isArray(this.curve)){this.curve=new _1._Line(this.curve[0],this.curve[1]);}};_1.Animation.prototype=new _3();_1._Animation=_1.Animation;_2.extend(_1.Animation,{duration:350,repeat:0,rate:20,_percent:0,_startRepeatCount:0,_getStep:function(){var _d=this._percent,_e=this.easing;return _e?_e(_d):_d;},_fire:function(_f,_10){var a=_10||[];if(this[_f]){if(_1.config.debugAtAllCosts){this[_f].apply(this,a);}else{try{this[_f].apply(this,a);}catch(e){console.error("exception in animation handler for:",_f);console.error(e);}}}return this;},play:function(_11,_12){var _13=this;if(_13._delayTimer){_13._clearTimer();}if(_12){_13._stopTimer();_13._active=_13._paused=false;_13._percent=0;}else{if(_13._active&&!_13._paused){return _13;}}_13._fire("beforeBegin",[_13.node]);var de=_11||_13.delay,_14=_2.hitch(_13,"_play",_12);if(de>0){_13._delayTimer=setTimeout(_14,de);return _13;}_14();return _13;},_play:function(_15){var _16=this;if(_16._delayTimer){_16._clearTimer();}_16._startTime=new Date().valueOf();if(_16._paused){_16._startTime-=_16.duration*_16._percent;}_16._active=true;_16._paused=false;var _17=_16.curve.getValue(_16._getStep());if(!_16._percent){if(!_16._startRepeatCount){_16._startRepeatCount=_16.repeat;}_16._fire("onBegin",[_17]);}_16._fire("onPlay",[_17]);_16._cycle();return _16;},pause:function(){var _18=this;if(_18._delayTimer){_18._clearTimer();}_18._stopTimer();if(!_18._active){return _18;}_18._paused=true;_18._fire("onPause",[_18.curve.getValue(_18._getStep())]);return _18;},gotoPercent:function(_19,_1a){var _1b=this;_1b._stopTimer();_1b._active=_1b._paused=true;_1b._percent=_19;if(_1a){_1b.play();}return _1b;},stop:function(_1c){var _1d=this;if(_1d._delayTimer){_1d._clearTimer();}if(!_1d._timer){return _1d;}_1d._stopTimer();if(_1c){_1d._percent=1;}_1d._fire("onStop",[_1d.curve.getValue(_1d._getStep())]);_1d._active=_1d._paused=false;return _1d;},status:function(){if(this._active){return this._paused?"paused":"playing";}return "stopped";},_cycle:function(){var _1e=this;if(_1e._active){var _1f=new Date().valueOf();var _20=(_1f-_1e._startTime)/(_1e.duration);if(_20>=1){_20=1;}_1e._percent=_20;if(_1e.easing){_20=_1e.easing(_20);}_1e._fire("onAnimate",[_1e.curve.getValue(_20)]);if(_1e._percent<1){_1e._startTimer();}else{_1e._active=false;if(_1e.repeat>0){_1e.repeat--;_1e.play(null,true);}else{if(_1e.repeat==-1){_1e.play(null,true);}else{if(_1e._startRepeatCount){_1e.repeat=_1e._startRepeatCount;_1e._startRepeatCount=0;}}}_1e._percent=0;_1e._fire("onEnd",[_1e.node]);!_1e.repeat&&_1e._stopTimer();}}return _1e;},_clearTimer:function(){clearTimeout(this._delayTimer);delete this._delayTimer;}});var ctr=0,_21=null,_22={run:function(){}};_2.extend(_1.Animation,{_startTimer:function(){if(!this._timer){this._timer=_5.connect(_22,"run",this,"_cycle");ctr++;}if(!_21){_21=setInterval(_2.hitch(_22,"run"),this.rate);}},_stopTimer:function(){if(this._timer){_5.disconnect(this._timer);this._timer=null;ctr--;}if(ctr<=0){clearInterval(_21);_21=null;ctr=0;}}});var _23=_6("ie")?function(_24){var ns=_24.style;if(!ns.width.length&&_8.get(_24,"width")=="auto"){ns.width="auto";}}:function(){};_1._fade=function(_25){_25.node=_7.byId(_25.node);var _26=_9({properties:{}},_25),_27=(_26.properties.opacity={});_27.start=!("start" in _26)?function(){return +_8.get(_26.node,"opacity")||0;}:_26.start;_27.end=_26.end;var _28=_1.animateProperty(_26);_5.connect(_28,"beforeBegin",_2.partial(_23,_26.node));return _28;};_1.fadeIn=function(_29){return _1._fade(_9({end:1},_29));};_1.fadeOut=function(_2a){return _1._fade(_9({end:0},_2a));};_1._defaultEasing=function(n){return 0.5+((Math.sin((n+1.5)*Math.PI))/2);};var _2b=function(_2c){this._properties=_2c;for(var p in _2c){var _2d=_2c[p];if(_2d.start instanceof _4){_2d.tempColor=new _4();}}};_2b.prototype.getValue=function(r){var ret={};for(var p in this._properties){var _2e=this._properties[p],_2f=_2e.start;if(_2f instanceof _4){ret[p]=_4.blendColors(_2f,_2e.end,r,_2e.tempColor).toCss();}else{if(!_2.isArray(_2f)){ret[p]=((_2e.end-_2f)*r)+_2f+(p!="opacity"?_2e.units||"px":0);}}}return ret;};_1.animateProperty=function(_30){var n=_30.node=_7.byId(_30.node);if(!_30.easing){_30.easing=_1._defaultEasing;}var _31=new _1.Animation(_30);_5.connect(_31,"beforeBegin",_31,function(){var pm={};for(var p in this.properties){if(p=="width"||p=="height"){this.node.display="block";}var _32=this.properties[p];if(_2.isFunction(_32)){_32=_32(n);}_32=pm[p]=_9({},(_2.isObject(_32)?_32:{end:_32}));if(_2.isFunction(_32.start)){_32.start=_32.start(n);}if(_2.isFunction(_32.end)){_32.end=_32.end(n);}var _33=(p.toLowerCase().indexOf("color")>=0);function _34(_35,p){var v={height:_35.offsetHeight,width:_35.offsetWidth}[p];if(v!==undefined){return v;}v=_8.get(_35,p);return (p=="opacity")?+v:(_33?v:parseFloat(v));};if(!("end" in _32)){_32.end=_34(n,p);}else{if(!("start" in _32)){_32.start=_34(n,p);}}if(_33){_32.start=new _4(_32.start);_32.end=new _4(_32.end);}else{_32.start=(p=="opacity")?+_32.start:parseFloat(_32.start);}}this.curve=new _2b(pm);});_5.connect(_31,"onAnimate",_2.hitch(_8,"set",_31.node));return _31;};_1.anim=function(_36,_37,_38,_39,_3a,_3b){return _1.animateProperty({node:_36,duration:_38||_1.Animation.prototype.duration,properties:_37,easing:_39,onEnd:_3a}).play(_3b||0);};return {_Line:_1._Line,Animation:_1.Animation,_fade:_1._fade,fadeIn:_1.fadeIn,fadeOut:_1.fadeOut,_defaultEasing:_1._defaultEasing,animateProperty:_1.animateProperty,anim:_1.anim};});
\ No newline at end of file
diff --git a/lib/dojo/_base/fx.js.uncompressed.js b/lib/dojo/_base/fx.js.uncompressed.js
new file mode 100644
index 000000000..cf52b0de1
--- /dev/null
+++ b/lib/dojo/_base/fx.js.uncompressed.js
@@ -0,0 +1,666 @@
+define("dojo/_base/fx", ["./kernel", "./lang", "../Evented", "./Color", "./connect", "./sniff", "../dom", "../dom-style"], function(dojo, lang, Evented, Color, connect, has, dom, style){
+	// module:
+	//		dojo/_base/fx
+	// summary:
+	//		This module defines the base dojo.fx implementation.
+	// notes:
+	//		Animation loosely package based on Dan Pupius' work, contributed under CLA; see
+	//		http://pupius.co.uk/js/Toolkit.Drawing.js
+
+	var _mixin = lang.mixin;
+
+	dojo._Line = function(/*int*/ start, /*int*/ end){
+		//	summary:
+		//		dojo._Line is the object used to generate values from a start value
+		//		to an end value
+		//	start: int
+		//		Beginning value for range
+		//	end: int
+		//		Ending value for range
+		this.start = start;
+		this.end = end;
+	};
+
+	dojo._Line.prototype.getValue = function(/*float*/ n){
+		//	summary: Returns the point on the line
+		//	n: a floating point number greater than 0 and less than 1
+		return ((this.end - this.start) * n) + this.start; // Decimal
+	};
+
+	dojo.Animation = function(args){
+		//	summary:
+		//		A generic animation class that fires callbacks into its handlers
+		//		object at various states.
+		//	description:
+		//		A generic animation class that fires callbacks into its handlers
+		//		object at various states. Nearly all dojo animation functions
+		//		return an instance of this method, usually without calling the
+		//		.play() method beforehand. Therefore, you will likely need to
+		//		call .play() on instances of `dojo.Animation` when one is
+		//		returned.
+		// args: Object
+		//		The 'magic argument', mixing all the properties into this
+		//		animation instance.
+
+		_mixin(this, args);
+		if(lang.isArray(this.curve)){
+			this.curve = new dojo._Line(this.curve[0], this.curve[1]);
+		}
+
+	};
+	dojo.Animation.prototype = new Evented();
+	// Alias to drop come 2.0:
+	dojo._Animation = dojo.Animation;
+
+	lang.extend(dojo.Animation, {
+		// duration: Integer
+		//		The time in milliseonds the animation will take to run
+		duration: 350,
+
+	/*=====
+		// curve: dojo._Line|Array
+		//		A two element array of start and end values, or a `dojo._Line` instance to be
+		//		used in the Animation.
+		curve: null,
+
+		// easing: Function?
+		//		A Function to adjust the acceleration (or deceleration) of the progress
+		//		across a dojo._Line
+		easing: null,
+	=====*/
+
+		// repeat: Integer?
+		//		The number of times to loop the animation
+		repeat: 0,
+
+		// rate: Integer?
+		//		the time in milliseconds to wait before advancing to next frame
+		//		(used as a fps timer: 1000/rate = fps)
+		rate: 20 /* 50 fps */,
+
+	/*=====
+		// delay: Integer?
+		//		The time in milliseconds to wait before starting animation after it
+		//		has been .play()'ed
+		delay: null,
+
+		// beforeBegin: Event?
+		//		Synthetic event fired before a dojo.Animation begins playing (synchronous)
+		beforeBegin: null,
+
+		// onBegin: Event?
+		//		Synthetic event fired as a dojo.Animation begins playing (useful?)
+		onBegin: null,
+
+		// onAnimate: Event?
+		//		Synthetic event fired at each interval of a `dojo.Animation`
+		onAnimate: null,
+
+		// onEnd: Event?
+		//		Synthetic event fired after the final frame of a `dojo.Animation`
+		onEnd: null,
+
+		// onPlay: Event?
+		//		Synthetic event fired any time a `dojo.Animation` is play()'ed
+		onPlay: null,
+
+		// onPause: Event?
+		//		Synthetic event fired when a `dojo.Animation` is paused
+		onPause: null,
+
+		// onStop: Event
+		//		Synthetic event fires when a `dojo.Animation` is stopped
+		onStop: null,
+
+	=====*/
+
+		_percent: 0,
+		_startRepeatCount: 0,
+
+		_getStep: function(){
+			var _p = this._percent,
+				_e = this.easing
+			;
+			return _e ? _e(_p) : _p;
+		},
+		_fire: function(/*Event*/ evt, /*Array?*/ args){
+			//	summary:
+			//		Convenience function.  Fire event "evt" and pass it the
+			//		arguments specified in "args".
+			//	description:
+			//		Convenience function.  Fire event "evt" and pass it the
+			//		arguments specified in "args".
+			//		Fires the callback in the scope of the `dojo.Animation`
+			//		instance.
+			//	evt:
+			//		The event to fire.
+			//	args:
+			//		The arguments to pass to the event.
+			var a = args||[];
+			if(this[evt]){
+				if(dojo.config.debugAtAllCosts){
+					this[evt].apply(this, a);
+				}else{
+					try{
+						this[evt].apply(this, a);
+					}catch(e){
+						// squelch and log because we shouldn't allow exceptions in
+						// synthetic event handlers to cause the internal timer to run
+						// amuck, potentially pegging the CPU. I'm not a fan of this
+						// squelch, but hopefully logging will make it clear what's
+						// going on
+						console.error("exception in animation handler for:", evt);
+						console.error(e);
+					}
+				}
+			}
+			return this; // dojo.Animation
+		},
+
+		play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
+			// summary:
+			//		Start the animation.
+			// delay:
+			//		How many milliseconds to delay before starting.
+			// gotoStart:
+			//		If true, starts the animation from the beginning; otherwise,
+			//		starts it from its current position.
+			// returns: dojo.Animation
+			//		The instance to allow chaining.
+
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			if(gotoStart){
+				_t._stopTimer();
+				_t._active = _t._paused = false;
+				_t._percent = 0;
+			}else if(_t._active && !_t._paused){
+				return _t;
+			}
+
+			_t._fire("beforeBegin", [_t.node]);
+
+			var de = delay || _t.delay,
+				_p = lang.hitch(_t, "_play", gotoStart);
+
+			if(de > 0){
+				_t._delayTimer = setTimeout(_p, de);
+				return _t;
+			}
+			_p();
+			return _t;	// dojo.Animation
+		},
+
+		_play: function(gotoStart){
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			_t._startTime = new Date().valueOf();
+			if(_t._paused){
+				_t._startTime -= _t.duration * _t._percent;
+			}
+
+			_t._active = true;
+			_t._paused = false;
+			var value = _t.curve.getValue(_t._getStep());
+			if(!_t._percent){
+				if(!_t._startRepeatCount){
+					_t._startRepeatCount = _t.repeat;
+				}
+				_t._fire("onBegin", [value]);
+			}
+
+			_t._fire("onPlay", [value]);
+
+			_t._cycle();
+			return _t; // dojo.Animation
+		},
+
+		pause: function(){
+			// summary: Pauses a running animation.
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			_t._stopTimer();
+			if(!_t._active){ return _t; /*dojo.Animation*/ }
+			_t._paused = true;
+			_t._fire("onPause", [_t.curve.getValue(_t._getStep())]);
+			return _t; // dojo.Animation
+		},
+
+		gotoPercent: function(/*Decimal*/ percent, /*Boolean?*/ andPlay){
+			//	summary:
+			//		Sets the progress of the animation.
+			//	percent:
+			//		A percentage in decimal notation (between and including 0.0 and 1.0).
+			//	andPlay:
+			//		If true, play the animation after setting the progress.
+			var _t = this;
+			_t._stopTimer();
+			_t._active = _t._paused = true;
+			_t._percent = percent;
+			if(andPlay){ _t.play(); }
+			return _t; // dojo.Animation
+		},
+
+		stop: function(/*boolean?*/ gotoEnd){
+			// summary: Stops a running animation.
+			// gotoEnd: If true, the animation will end.
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			if(!_t._timer){ return _t; /* dojo.Animation */ }
+			_t._stopTimer();
+			if(gotoEnd){
+				_t._percent = 1;
+			}
+			_t._fire("onStop", [_t.curve.getValue(_t._getStep())]);
+			_t._active = _t._paused = false;
+			return _t; // dojo.Animation
+		},
+
+		status: function(){
+			// summary:
+			//		Returns a string token representation of the status of
+			//		the animation, one of: "paused", "playing", "stopped"
+			if(this._active){
+				return this._paused ? "paused" : "playing"; // String
+			}
+			return "stopped"; // String
+		},
+
+		_cycle: function(){
+			var _t = this;
+			if(_t._active){
+				var curr = new Date().valueOf();
+				var step = (curr - _t._startTime) / (_t.duration);
+
+				if(step >= 1){
+					step = 1;
+				}
+				_t._percent = step;
+
+				// Perform easing
+				if(_t.easing){
+					step = _t.easing(step);
+				}
+
+				_t._fire("onAnimate", [_t.curve.getValue(step)]);
+
+				if(_t._percent < 1){
+					_t._startTimer();
+				}else{
+					_t._active = false;
+
+					if(_t.repeat > 0){
+						_t.repeat--;
+						_t.play(null, true);
+					}else if(_t.repeat == -1){
+						_t.play(null, true);
+					}else{
+						if(_t._startRepeatCount){
+							_t.repeat = _t._startRepeatCount;
+							_t._startRepeatCount = 0;
+						}
+					}
+					_t._percent = 0;
+					_t._fire("onEnd", [_t.node]);
+					!_t.repeat && _t._stopTimer();
+				}
+			}
+			return _t; // dojo.Animation
+		},
+
+		_clearTimer: function(){
+			// summary: Clear the play delay timer
+			clearTimeout(this._delayTimer);
+			delete this._delayTimer;
+		}
+
+	});
+
+	// the local timer, stubbed into all Animation instances
+	var ctr = 0,
+		timer = null,
+		runner = {
+			run: function(){}
+		};
+
+	lang.extend(dojo.Animation, {
+
+		_startTimer: function(){
+			if(!this._timer){
+				this._timer = connect.connect(runner, "run", this, "_cycle");
+				ctr++;
+			}
+			if(!timer){
+				timer = setInterval(lang.hitch(runner, "run"), this.rate);
+			}
+		},
+
+		_stopTimer: function(){
+			if(this._timer){
+				connect.disconnect(this._timer);
+				this._timer = null;
+				ctr--;
+			}
+			if(ctr <= 0){
+				clearInterval(timer);
+				timer = null;
+				ctr = 0;
+			}
+		}
+
+	});
+
+	var _makeFadeable =
+				has("ie") ? function(node){
+			// only set the zoom if the "tickle" value would be the same as the
+			// default
+			var ns = node.style;
+			// don't set the width to auto if it didn't already cascade that way.
+			// We don't want to f anyones designs
+			if(!ns.width.length && style.get(node, "width") == "auto"){
+				ns.width = "auto";
+			}
+		} :
+				function(){};
+
+	dojo._fade = function(/*Object*/ args){
+		//	summary:
+		//		Returns an animation that will fade the node defined by
+		//		args.node from the start to end values passed (args.start
+		//		args.end) (end is mandatory, start is optional)
+
+		args.node = dom.byId(args.node);
+		var fArgs = _mixin({ properties: {} }, args),
+			props = (fArgs.properties.opacity = {});
+
+		props.start = !("start" in fArgs) ?
+			function(){
+				return +style.get(fArgs.node, "opacity")||0;
+			} : fArgs.start;
+		props.end = fArgs.end;
+
+		var anim = dojo.animateProperty(fArgs);
+		connect.connect(anim, "beforeBegin", lang.partial(_makeFadeable, fArgs.node));
+
+		return anim; // dojo.Animation
+	};
+
+	/*=====
+	dojo.__FadeArgs = function(node, duration, easing){
+		//	node: DOMNode|String
+		//		The node referenced in the animation
+		//	duration: Integer?
+		//		Duration of the animation in milliseconds.
+		//	easing: Function?
+		//		An easing function.
+		this.node = node;
+		this.duration = duration;
+		this.easing = easing;
+	}
+	=====*/
+
+	dojo.fadeIn = function(/*dojo.__FadeArgs*/ args){
+		// summary:
+		//		Returns an animation that will fade node defined in 'args' from
+		//		its current opacity to fully opaque.
+		return dojo._fade(_mixin({ end: 1 }, args)); // dojo.Animation
+	};
+
+	dojo.fadeOut = function(/*dojo.__FadeArgs*/ args){
+		// summary:
+		//		Returns an animation that will fade node defined in 'args'
+		//		from its current opacity to fully transparent.
+		return dojo._fade(_mixin({ end: 0 }, args)); // dojo.Animation
+	};
+
+	dojo._defaultEasing = function(/*Decimal?*/ n){
+		// summary: The default easing function for dojo.Animation(s)
+		return 0.5 + ((Math.sin((n + 1.5) * Math.PI)) / 2);	// Decimal
+	};
+
+	var PropLine = function(properties){
+		// PropLine is an internal class which is used to model the values of
+		// an a group of CSS properties across an animation lifecycle. In
+		// particular, the "getValue" function handles getting interpolated
+		// values between start and end for a particular CSS value.
+		this._properties = properties;
+		for(var p in properties){
+			var prop = properties[p];
+			if(prop.start instanceof Color){
+				// create a reusable temp color object to keep intermediate results
+				prop.tempColor = new Color();
+			}
+		}
+	};
+
+	PropLine.prototype.getValue = function(r){
+		var ret = {};
+		for(var p in this._properties){
+			var prop = this._properties[p],
+				start = prop.start;
+			if(start instanceof Color){
+				ret[p] = Color.blendColors(start, prop.end, r, prop.tempColor).toCss();
+			}else if(!lang.isArray(start)){
+				ret[p] = ((prop.end - start) * r) + start + (p != "opacity" ? prop.units || "px" : 0);
+			}
+		}
+		return ret;
+	};
+
+	/*=====
+	dojo.declare("dojo.__AnimArgs", [dojo.__FadeArgs], {
+		// Properties: Object?
+		//	A hash map of style properties to Objects describing the transition,
+		//	such as the properties of dojo._Line with an additional 'units' property
+		properties: {}
+
+		//TODOC: add event callbacks
+	});
+	=====*/
+
+	dojo.animateProperty = function(/*dojo.__AnimArgs*/ args){
+		// summary:
+		//		Returns an animation that will transition the properties of
+		//		node defined in `args` depending how they are defined in
+		//		`args.properties`
+		//
+		// description:
+		//		`dojo.animateProperty` is the foundation of most `dojo.fx`
+		//		animations. It takes an object of "properties" corresponding to
+		//		style properties, and animates them in parallel over a set
+		//		duration.
+		//
+		// example:
+		//		A simple animation that changes the width of the specified node.
+		//	|	dojo.animateProperty({
+		//	|		node: "nodeId",
+		//	|		properties: { width: 400 },
+		//	|	}).play();
+		//		Dojo figures out the start value for the width and converts the
+		//		integer specified for the width to the more expressive but
+		//		verbose form `{ width: { end: '400', units: 'px' } }` which you
+		//		can also specify directly. Defaults to 'px' if ommitted.
+		//
+		// example:
+		//		Animate width, height, and padding over 2 seconds... the
+		//		pedantic way:
+		//	|	dojo.animateProperty({ node: node, duration:2000,
+		//	|		properties: {
+		//	|			width: { start: '200', end: '400', units:"px" },
+		//	|			height: { start:'200', end: '400', units:"px" },
+		//	|			paddingTop: { start:'5', end:'50', units:"px" }
+		//	|		}
+		//	|	}).play();
+		//		Note 'paddingTop' is used over 'padding-top'. Multi-name CSS properties
+		//		are written using "mixed case", as the hyphen is illegal as an object key.
+		//
+		// example:
+		//		Plug in a different easing function and register a callback for
+		//		when the animation ends. Easing functions accept values between
+		//		zero and one and return a value on that basis. In this case, an
+		//		exponential-in curve.
+		//	|	dojo.animateProperty({
+		//	|		node: "nodeId",
+		//	|		// dojo figures out the start value
+		//	|		properties: { width: { end: 400 } },
+		//	|		easing: function(n){
+		//	|			return (n==0) ? 0 : Math.pow(2, 10 * (n - 1));
+		//	|		},
+		//	|		onEnd: function(node){
+		//	|			// called when the animation finishes. The animation
+		//	|			// target is passed to this function
+		//	|		}
+		//	|	}).play(500); // delay playing half a second
+		//
+		// example:
+		//		Like all `dojo.Animation`s, animateProperty returns a handle to the
+		//		Animation instance, which fires the events common to Dojo FX. Use `dojo.connect`
+		//		to access these events outside of the Animation definiton:
+		//	|	var anim = dojo.animateProperty({
+		//	|		node:"someId",
+		//	|		properties:{
+		//	|			width:400, height:500
+		//	|		}
+		//	|	});
+		//	|	dojo.connect(anim,"onEnd", function(){
+		//	|		console.log("animation ended");
+		//	|	});
+		//	|	// play the animation now:
+		//	|	anim.play();
+		//
+		// example:
+		//		Each property can be a function whose return value is substituted along.
+		//		Additionally, each measurement (eg: start, end) can be a function. The node
+		//		reference is passed direcly to callbacks.
+		//	|	dojo.animateProperty({
+		//	|		node:"mine",
+		//	|		properties:{
+		//	|			height:function(node){
+		//	|				// shrink this node by 50%
+		//	|				return dojo.position(node).h / 2
+		//	|			},
+		//	|			width:{
+		//	|				start:function(node){ return 100; },
+		//	|				end:function(node){ return 200; }
+		//	|			}
+		//	|		}
+		//	|	}).play();
+		//
+
+		var n = args.node = dom.byId(args.node);
+		if(!args.easing){ args.easing = dojo._defaultEasing; }
+
+		var anim = new dojo.Animation(args);
+		connect.connect(anim, "beforeBegin", anim, function(){
+			var pm = {};
+			for(var p in this.properties){
+				// Make shallow copy of properties into pm because we overwrite
+				// some values below. In particular if start/end are functions
+				// we don't want to overwrite them or the functions won't be
+				// called if the animation is reused.
+				if(p == "width" || p == "height"){
+					this.node.display = "block";
+				}
+				var prop = this.properties[p];
+				if(lang.isFunction(prop)){
+					prop = prop(n);
+				}
+				prop = pm[p] = _mixin({}, (lang.isObject(prop) ? prop: { end: prop }));
+
+				if(lang.isFunction(prop.start)){
+					prop.start = prop.start(n);
+				}
+				if(lang.isFunction(prop.end)){
+					prop.end = prop.end(n);
+				}
+				var isColor = (p.toLowerCase().indexOf("color") >= 0);
+				function getStyle(node, p){
+					// dojo.style(node, "height") can return "auto" or "" on IE; this is more reliable:
+					var v = { height: node.offsetHeight, width: node.offsetWidth }[p];
+					if(v !== undefined){ return v; }
+					v = style.get(node, p);
+					return (p == "opacity") ? +v : (isColor ? v : parseFloat(v));
+				}
+				if(!("end" in prop)){
+					prop.end = getStyle(n, p);
+				}else if(!("start" in prop)){
+					prop.start = getStyle(n, p);
+				}
+
+				if(isColor){
+					prop.start = new Color(prop.start);
+					prop.end = new Color(prop.end);
+				}else{
+					prop.start = (p == "opacity") ? +prop.start : parseFloat(prop.start);
+				}
+			}
+			this.curve = new PropLine(pm);
+		});
+		connect.connect(anim, "onAnimate", lang.hitch(style, "set", anim.node));
+		return anim; // dojo.Animation
+	};
+
+	dojo.anim = function(	/*DOMNode|String*/	node,
+							/*Object*/			properties,
+							/*Integer?*/		duration,
+							/*Function?*/		easing,
+							/*Function?*/		onEnd,
+							/*Integer?*/		delay){
+		//	summary:
+		//		A simpler interface to `dojo.animateProperty()`, also returns
+		//		an instance of `dojo.Animation` but begins the animation
+		//		immediately, unlike nearly every other Dojo animation API.
+		//	description:
+		//		`dojo.anim` is a simpler (but somewhat less powerful) version
+		//		of `dojo.animateProperty`.  It uses defaults for many basic properties
+		//		and allows for positional parameters to be used in place of the
+		//		packed "property bag" which is used for other Dojo animation
+		//		methods.
+		//
+		//		The `dojo.Animation` object returned from `dojo.anim` will be
+		//		already playing when it is returned from this function, so
+		//		calling play() on it again is (usually) a no-op.
+		//	node:
+		//		a DOM node or the id of a node to animate CSS properties on
+		//	duration:
+		//		The number of milliseconds over which the animation
+		//		should run. Defaults to the global animation default duration
+		//		(350ms).
+		//	easing:
+		//		An easing function over which to calculate acceleration
+		//		and deceleration of the animation through its duration.
+		//		A default easing algorithm is provided, but you may
+		//		plug in any you wish. A large selection of easing algorithms
+		//		are available in `dojo.fx.easing`.
+		//	onEnd:
+		//		A function to be called when the animation finishes
+		//		running.
+		//	delay:
+		//		The number of milliseconds to delay beginning the
+		//		animation by. The default is 0.
+		//	example:
+		//		Fade out a node
+		//	|	dojo.anim("id", { opacity: 0 });
+		//	example:
+		//		Fade out a node over a full second
+		//	|	dojo.anim("id", { opacity: 0 }, 1000);
+		return dojo.animateProperty({ // dojo.Animation
+			node: node,
+			duration: duration || dojo.Animation.prototype.duration,
+			properties: properties,
+			easing: easing,
+			onEnd: onEnd
+		}).play(delay || 0);
+	};
+
+	return {
+		_Line: dojo._Line,
+		Animation: dojo.Animation,
+		_fade: dojo._fade,
+		fadeIn: dojo.fadeIn,
+		fadeOut: dojo.fadeOut,
+		_defaultEasing: dojo._defaultEasing,
+		animateProperty: dojo.animateProperty,
+		anim: dojo.anim
+	};
+});
diff --git a/lib/dojo/_base/html.js b/lib/dojo/_base/html.js
index 8661b2b12..89f6a5192 100644
--- a/lib/dojo/_base/html.js
+++ b/lib/dojo/_base/html.js
@@ -4,1833 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.html"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.html"] = true;
-dojo.provide("dojo._base.html");
-dojo.require("dojo._base.lang");
-
-
-// FIXME: need to add unit tests for all the semi-public methods
-
-try{
-	document.execCommand("BackgroundImageCache", false, true);
-}catch(e){
-	// sane browsers don't have cache "issues"
-}
-
-// =============================
-// DOM Functions
-// =============================
-
-/*=====
-dojo.byId = function(id, doc){
-	//	summary:
-	//		Returns DOM node with matching `id` attribute or `null`
-	//		if not found. If `id` is a DomNode, this function is a no-op.
-	//
-	//	id: String|DOMNode
-	//	 	A string to match an HTML id attribute or a reference to a DOM Node
-	//
-	//	doc: Document?
-	//		Document to work in. Defaults to the current value of
-	//		dojo.doc.  Can be used to retrieve
-	//		node references from other documents.
-	//
-	//	example:
-	//	Look up a node by ID:
-	//	|	var n = dojo.byId("foo");
-	//
-	//	example:
-	//	Check if a node exists, and use it.
-	//	|	var n = dojo.byId("bar");
-	//	|	if(n){ doStuff() ... }
-	//
-	//	example:
-	//	Allow string or DomNode references to be passed to a custom function:
-	//	|	var foo = function(nodeOrId){
-	//	|		nodeOrId = dojo.byId(nodeOrId);
-	//	|		// ... more stuff
-	//	|	}
-=====*/
-
-if(dojo.isIE){
-	dojo.byId = function(id, doc){
-		if(typeof id != "string"){
-			return id;
-		}
-		var _d = doc || dojo.doc, te = _d.getElementById(id);
-		// attributes.id.value is better than just id in case the
-		// user has a name=id inside a form
-		if(te && (te.attributes.id.value == id || te.id == id)){
-			return te;
-		}else{
-			var eles = _d.all[id];
-			if(!eles || eles.nodeName){
-				eles = [eles];
-			}
-			// if more than 1, choose first with the correct id
-			var i=0;
-			while((te=eles[i++])){
-				if((te.attributes && te.attributes.id && te.attributes.id.value == id)
-					|| te.id == id){
-					return te;
-				}
-			}
-		}
-	};
-}else{
-	dojo.byId = function(id, doc){
-		// inline'd type check.
-		// be sure to return null per documentation, to match IE branch.
-		return ((typeof id == "string") ? (doc || dojo.doc).getElementById(id) : id) || null; // DomNode
-	};
-}
-/*=====
-};
-=====*/
-
-(function(){
-	var d = dojo;
-	var byId = d.byId;
-
-	var _destroyContainer = null,
-		_destroyDoc;
-		d.addOnWindowUnload(function(){
-		_destroyContainer = null; //prevent IE leak
-	});
-	
-/*=====
-	dojo._destroyElement = function(node){
-		// summary:
-		// 		Existing alias for `dojo.destroy`. Deprecated, will be removed
-		// 		in 2.0
-	}
-=====*/
-	dojo._destroyElement = dojo.destroy = function(/*String|DomNode*/node){
-		//	summary:
-		//		Removes a node from its parent, clobbering it and all of its
-		//		children.
-		//
-		//	description:
-		//		Removes a node from its parent, clobbering it and all of its
-		//		children. Function only works with DomNodes, and returns nothing.
-		//
-		//	node:
-		//		A String ID or DomNode reference of the element to be destroyed
-		//
-		//	example:
-		//	Destroy a node byId:
-		//	|	dojo.destroy("someId");
-		//
-		//	example:
-		//	Destroy all nodes in a list by reference:
-		//	|	dojo.query(".someNode").forEach(dojo.destroy);
-
-		node = byId(node);
-		try{
-			var doc = node.ownerDocument;
-			// cannot use _destroyContainer.ownerDocument since this can throw an exception on IE
-			if(!_destroyContainer || _destroyDoc != doc){
-				_destroyContainer = doc.createElement("div");
-				_destroyDoc = doc;
-			}
-			_destroyContainer.appendChild(node.parentNode ? node.parentNode.removeChild(node) : node);
-			// NOTE: see http://trac.dojotoolkit.org/ticket/2931. This may be a bug and not a feature
-			_destroyContainer.innerHTML = "";
-		}catch(e){
-			/* squelch */
-		}
-	};
-
-	dojo.isDescendant = function(/*DomNode|String*/node, /*DomNode|String*/ancestor){
-		//	summary:
-		//		Returns true if node is a descendant of ancestor
-		//	node: string id or node reference to test
-		//	ancestor: string id or node reference of potential parent to test against
-		//
-		// example:
-		//	Test is node id="bar" is a descendant of node id="foo"
-		//	|	if(dojo.isDescendant("bar", "foo")){ ... }
-		try{
-			node = byId(node);
-			ancestor = byId(ancestor);
-			while(node){
-				if(node == ancestor){
-					return true; // Boolean
-				}
-				node = node.parentNode;
-			}
-		}catch(e){ /* squelch, return false */ }
-		return false; // Boolean
-	};
-
-	dojo.setSelectable = function(/*DomNode|String*/node, /*Boolean*/selectable){
-		//	summary:
-		//		Enable or disable selection on a node
-		//	node:
-		//		id or reference to node
-		//	selectable:
-		//		state to put the node in. false indicates unselectable, true
-		//		allows selection.
-		//	example:
-		//	Make the node id="bar" unselectable
-		//	|	dojo.setSelectable("bar");
-		//	example:
-		//	Make the node id="bar" selectable
-		//	|	dojo.setSelectable("bar", true);
-		node = byId(node);
-				if(d.isMozilla){
-			node.style.MozUserSelect = selectable ? "" : "none";
-		}else if(d.isKhtml || d.isWebKit){
-					node.style.KhtmlUserSelect = selectable ? "auto" : "none";
-				}else if(d.isIE){
-			var v = (node.unselectable = selectable ? "" : "on");
-			d.query("*", node).forEach("item.unselectable = '"+v+"'");
-		}
-				//FIXME: else?  Opera?
-	};
-
-	var _insertBefore = function(/*DomNode*/node, /*DomNode*/ref){
-		var parent = ref.parentNode;
-		if(parent){
-			parent.insertBefore(node, ref);
-		}
-	};
-
-	var _insertAfter = function(/*DomNode*/node, /*DomNode*/ref){
-		//	summary:
-		//		Try to insert node after ref
-		var parent = ref.parentNode;
-		if(parent){
-			if(parent.lastChild == ref){
-				parent.appendChild(node);
-			}else{
-				parent.insertBefore(node, ref.nextSibling);
-			}
-		}
-	};
-
-	dojo.place = function(node, refNode, position){
-		//	summary:
-		//		Attempt to insert node into the DOM, choosing from various positioning options.
-		//		Returns the first argument resolved to a DOM node.
-		//
-		//	node: String|DomNode
-		//		id or node reference, or HTML fragment starting with "<" to place relative to refNode
-		//
-		//	refNode: String|DomNode
-		//		id or node reference to use as basis for placement
-		//
-		//	position: String|Number?
-		//		string noting the position of node relative to refNode or a
-		//		number indicating the location in the childNodes collection of refNode.
-		//		Accepted string values are:
-		//	|	* before
-		//	|	* after
-		//	|	* replace
-		//	|	* only
-		//	|	* first
-		//	|	* last
-		//		"first" and "last" indicate positions as children of refNode, "replace" replaces refNode,
-		//		"only" replaces all children.  position defaults to "last" if not specified
-		//
-		//	returns: DomNode
-		//		Returned values is the first argument resolved to a DOM node.
-		//
-		//		.place() is also a method of `dojo.NodeList`, allowing `dojo.query` node lookups.
-		//
-		// example:
-		//		Place a node by string id as the last child of another node by string id:
-		//	|	dojo.place("someNode", "anotherNode");
-		//
-		// example:
-		//		Place a node by string id before another node by string id
-		//	|	dojo.place("someNode", "anotherNode", "before");
-		//
-		// example:
-		//		Create a Node, and place it in the body element (last child):
-		//	|	dojo.place("<div></div>", dojo.body());
-		//
-		// example:
-		//		Put a new LI as the first child of a list by id:
-		//	|	dojo.place("<li></li>", "someUl", "first");
-
-		refNode = byId(refNode);
-		if(typeof node == "string"){ // inline'd type check
-			node = /^\s*</.test(node) ? d._toDom(node, refNode.ownerDocument) : byId(node);
-		}
-		if(typeof position == "number"){ // inline'd type check
-			var cn = refNode.childNodes;
-			if(!cn.length || cn.length <= position){
-				refNode.appendChild(node);
-			}else{
-				_insertBefore(node, cn[position < 0 ? 0 : position]);
-			}
-		}else{
-			switch(position){
-				case "before":
-					_insertBefore(node, refNode);
-					break;
-				case "after":
-					_insertAfter(node, refNode);
-					break;
-				case "replace":
-					refNode.parentNode.replaceChild(node, refNode);
-					break;
-				case "only":
-					d.empty(refNode);
-					refNode.appendChild(node);
-					break;
-				case "first":
-					if(refNode.firstChild){
-						_insertBefore(node, refNode.firstChild);
-						break;
-					}
-					// else fallthrough...
-				default: // aka: last
-					refNode.appendChild(node);
-			}
-		}
-		return node; // DomNode
-	};
-
-	// Box functions will assume this model.
-	// On IE/Opera, BORDER_BOX will be set if the primary document is in quirks mode.
-	// Can be set to change behavior of box setters.
-
-	// can be either:
-	//	"border-box"
-	//	"content-box" (default)
-	dojo.boxModel = "content-box";
-
-	// We punt per-node box mode testing completely.
-	// If anybody cares, we can provide an additional (optional) unit
-	// that overrides existing code to include per-node box sensitivity.
-
-	// Opera documentation claims that Opera 9 uses border-box in BackCompat mode.
-	// but experiments (Opera 9.10.8679 on Windows Vista) indicate that it actually continues to use content-box.
-	// IIRC, earlier versions of Opera did in fact use border-box.
-	// Opera guys, this is really confusing. Opera being broken in quirks mode is not our fault.
-
-		if(d.isIE /*|| dojo.isOpera*/){
-		// client code may have to adjust if compatMode varies across iframes
-		d.boxModel = document.compatMode == "BackCompat" ? "border-box" : "content-box";
-	}
-	
-	// =============================
-	// Style Functions
-	// =============================
-
-	// getComputedStyle drives most of the style code.
-	// Wherever possible, reuse the returned object.
-	//
-	// API functions below that need to access computed styles accept an
-	// optional computedStyle parameter.
-	// If this parameter is omitted, the functions will call getComputedStyle themselves.
-	// This way, calling code can access computedStyle once, and then pass the reference to
-	// multiple API functions.
-
-/*=====
-	dojo.getComputedStyle = function(node){
-		//	summary:
-		//		Returns a "computed style" object.
-		//
-		//	description:
-		//		Gets a "computed style" object which can be used to gather
-		//		information about the current state of the rendered node.
-		//
-		//		Note that this may behave differently on different browsers.
-		//		Values may have different formats and value encodings across
-		//		browsers.
-		//
-		//		Note also that this method is expensive.  Wherever possible,
-		//		reuse the returned object.
-		//
-		//		Use the dojo.style() method for more consistent (pixelized)
-		//		return values.
-		//
-		//	node: DOMNode
-		//		A reference to a DOM node. Does NOT support taking an
-		//		ID string for speed reasons.
-		//	example:
-		//	|	dojo.getComputedStyle(dojo.byId('foo')).borderWidth;
-		//
-		//	example:
-		//	Reusing the returned object, avoiding multiple lookups:
-		//	|	var cs = dojo.getComputedStyle(dojo.byId("someNode"));
-		//	|	var w = cs.width, h = cs.height;
-		return; // CSS2Properties
-	}
-=====*/
-
-	// Although we normally eschew argument validation at this
-	// level, here we test argument 'node' for (duck)type,
-	// by testing nodeType, ecause 'document' is the 'parentNode' of 'body'
-	// it is frequently sent to this function even
-	// though it is not Element.
-	var gcs;
-		if(d.isWebKit){
-			gcs = function(/*DomNode*/node){
-			var s;
-			if(node.nodeType == 1){
-				var dv = node.ownerDocument.defaultView;
-				s = dv.getComputedStyle(node, null);
-				if(!s && node.style){
-					node.style.display = "";
-					s = dv.getComputedStyle(node, null);
-				}
-			}
-			return s || {};
-		};
-		}else if(d.isIE){
-		gcs = function(node){
-			// IE (as of 7) doesn't expose Element like sane browsers
-			return node.nodeType == 1 /* ELEMENT_NODE*/ ? node.currentStyle : {};
-		};
-	}else{
-		gcs = function(node){
-			return node.nodeType == 1 ?
-				node.ownerDocument.defaultView.getComputedStyle(node, null) : {};
-		};
-	}
-		dojo.getComputedStyle = gcs;
-
-		if(!d.isIE){
-			d._toPixelValue = function(element, value){
-			// style values can be floats, client code may want
-			// to round for integer pixels.
-			return parseFloat(value) || 0;
-		};
-		}else{
-		d._toPixelValue = function(element, avalue){
-			if(!avalue){ return 0; }
-			// on IE7, medium is usually 4 pixels
-			if(avalue == "medium"){ return 4; }
-			// style values can be floats, client code may
-			// want to round this value for integer pixels.
-			if(avalue.slice && avalue.slice(-2) == 'px'){ return parseFloat(avalue); }
-			with(element){
-				var sLeft = style.left;
-				var rsLeft = runtimeStyle.left;
-				runtimeStyle.left = currentStyle.left;
-				try{
-					// 'avalue' may be incompatible with style.left, which can cause IE to throw
-					// this has been observed for border widths using "thin", "medium", "thick" constants
-					// those particular constants could be trapped by a lookup
-					// but perhaps there are more
-					style.left = avalue;
-					avalue = style.pixelLeft;
-				}catch(e){
-					avalue = 0;
-				}
-				style.left = sLeft;
-				runtimeStyle.left = rsLeft;
-			}
-			return avalue;
-		};
-	}
-		var px = d._toPixelValue;
-
-	// FIXME: there opacity quirks on FF that we haven't ported over. Hrm.
-	/*=====
-	dojo._getOpacity = function(node){
-			//	summary:
-			//		Returns the current opacity of the passed node as a
-			//		floating-point value between 0 and 1.
-			//	node: DomNode
-			//		a reference to a DOM node. Does NOT support taking an
-			//		ID string for speed reasons.
-			//	returns: Number between 0 and 1
-			return; // Number
-	}
-	=====*/
-
-		var astr = "DXImageTransform.Microsoft.Alpha";
-	var af = function(n, f){
-		try{
-			return n.filters.item(astr);
-		}catch(e){
-			return f ? {} : null;
-		}
-	};
-
-		dojo._getOpacity =
-			d.isIE < 9 ? function(node){
-			try{
-				return af(node).Opacity / 100; // Number
-			}catch(e){
-				return 1; // Number
-			}
-		} :
-			function(node){
-			return gcs(node).opacity;
-		};
-
-	/*=====
-	dojo._setOpacity = function(node, opacity){
-			//	summary:
-			//		set the opacity of the passed node portably. Returns the
-			//		new opacity of the node.
-			//	node: DOMNode
-			//		a reference to a DOM node. Does NOT support taking an
-			//		ID string for performance reasons.
-			//	opacity: Number
-			//		A Number between 0 and 1. 0 specifies transparent.
-			//	returns: Number between 0 and 1
-			return; // Number
-	}
-	=====*/
-
-	dojo._setOpacity =
-				d.isIE < 9 ? function(/*DomNode*/node, /*Number*/opacity){
-			var ov = opacity * 100, opaque = opacity == 1;
-			node.style.zoom = opaque ? "" : 1;
-
-			if(!af(node)){
-				if(opaque){
-					return opacity;
-				}
-				node.style.filter += " progid:" + astr + "(Opacity=" + ov + ")";
-			}else{
-				af(node, 1).Opacity = ov;
-			}
-
-			// on IE7 Alpha(Filter opacity=100) makes text look fuzzy so disable it altogether (bug #2661),
-			//but still update the opacity value so we can get a correct reading if it is read later.
-			af(node, 1).Enabled = !opaque;
-
-			if(node.nodeName.toLowerCase() == "tr"){
-				d.query("> td", node).forEach(function(i){
-					d._setOpacity(i, opacity);
-				});
-			}
-			return opacity;
-		} :
-				function(node, opacity){
-			return node.style.opacity = opacity;
-		};
-
-	var _pixelNamesCache = {
-		left: true, top: true
-	};
-	var _pixelRegExp = /margin|padding|width|height|max|min|offset/;  // |border
-	var _toStyleValue = function(node, type, value){
-		type = type.toLowerCase(); // FIXME: should we really be doing string case conversion here? Should we cache it? Need to profile!
-				if(d.isIE){
-			if(value == "auto"){
-				if(type == "height"){ return node.offsetHeight; }
-				if(type == "width"){ return node.offsetWidth; }
-			}
-			if(type == "fontweight"){
-				switch(value){
-					case 700: return "bold";
-					case 400:
-					default: return "normal";
-				}
-			}
-		}
-				if(!(type in _pixelNamesCache)){
-			_pixelNamesCache[type] = _pixelRegExp.test(type);
-		}
-		return _pixelNamesCache[type] ? px(node, value) : value;
-	};
-
-	var _floatStyle = d.isIE ? "styleFloat" : "cssFloat",
-		_floatAliases = { "cssFloat": _floatStyle, "styleFloat": _floatStyle, "float": _floatStyle }
-	;
-
-	// public API
-
-	dojo.style = function(	/*DomNode|String*/ node,
-							/*String?|Object?*/ style,
-							/*String?*/ value){
-		//	summary:
-		//		Accesses styles on a node. If 2 arguments are
-		//		passed, acts as a getter. If 3 arguments are passed, acts
-		//		as a setter.
-		//	description:
-		//		Getting the style value uses the computed style for the node, so the value
-		//		will be a calculated value, not just the immediate node.style value.
-		//		Also when getting values, use specific style names,
-		//		like "borderBottomWidth" instead of "border" since compound values like
-		//		"border" are not necessarily reflected as expected.
-		//		If you want to get node dimensions, use `dojo.marginBox()`,
-		//		`dojo.contentBox()` or `dojo.position()`.
-		//	node:
-		//		id or reference to node to get/set style for
-		//	style:
-		//		the style property to set in DOM-accessor format
-		//		("borderWidth", not "border-width") or an object with key/value
-		//		pairs suitable for setting each property.
-		//	value:
-		//		If passed, sets value on the node for style, handling
-		//		cross-browser concerns.  When setting a pixel value,
-		//		be sure to include "px" in the value. For instance, top: "200px".
-		//		Otherwise, in some cases, some browsers will not apply the style.
-		//	example:
-		//		Passing only an ID or node returns the computed style object of
-		//		the node:
-		//	|	dojo.style("thinger");
-		//	example:
-		//		Passing a node and a style property returns the current
-		//		normalized, computed value for that property:
-		//	|	dojo.style("thinger", "opacity"); // 1 by default
-		//
-		//	example:
-		//		Passing a node, a style property, and a value changes the
-		//		current display of the node and returns the new computed value
-		//	|	dojo.style("thinger", "opacity", 0.5); // == 0.5
-		//
-		//	example:
-		//		Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node:
-		//	|	dojo.style("thinger", {
-		//	|		"opacity": 0.5,
-		//	|		"border": "3px solid black",
-		//	|		"height": "300px"
-		//	|	});
-		//
-		// 	example:
-		//		When the CSS style property is hyphenated, the JavaScript property is camelCased.
-		//		font-size becomes fontSize, and so on.
-		//	|	dojo.style("thinger",{
-		//	|		fontSize:"14pt",
-		//	|		letterSpacing:"1.2em"
-		//	|	});
-		//
-		//	example:
-		//		dojo.NodeList implements .style() using the same syntax, omitting the "node" parameter, calling
-		//		dojo.style() on every element of the list. See: `dojo.query()` and `dojo.NodeList()`
-		//	|	dojo.query(".someClassName").style("visibility","hidden");
-		//	|	// or
-		//	|	dojo.query("#baz > div").style({
-		//	|		opacity:0.75,
-		//	|		fontSize:"13pt"
-		//	|	});
-
-		var n = byId(node), args = arguments.length, op = (style == "opacity");
-		style = _floatAliases[style] || style;
-		if(args == 3){
-			return op ? d._setOpacity(n, value) : n.style[style] = value; /*Number*/
-		}
-		if(args == 2 && op){
-			return d._getOpacity(n);
-		}
-		var s = gcs(n);
-		if(args == 2 && typeof style != "string"){ // inline'd type check
-			for(var x in style){
-				d.style(node, x, style[x]);
-			}
-			return s;
-		}
-		return (args == 1) ? s : _toStyleValue(n, style, s[style] || n.style[style]); /* CSS2Properties||String||Number */
-	};
-
-	// =============================
-	// Box Functions
-	// =============================
-
-	dojo._getPadExtents = function(/*DomNode*/n, /*Object*/computedStyle){
-		//	summary:
-		// 		Returns object with special values specifically useful for node
-		// 		fitting.
-		//	description:
-		//		Returns an object with `w`, `h`, `l`, `t` properties:
-		//	|		l/t = left/top padding (respectively)
-		//	|		w = the total of the left and right padding
-		//	|		h = the total of the top and bottom padding
-		//		If 'node' has position, l/t forms the origin for child nodes.
-		//		The w/h are used for calculating boxes.
-		//		Normally application code will not need to invoke this
-		//		directly, and will use the ...box... functions instead.
-		var
-			s = computedStyle||gcs(n),
-			l = px(n, s.paddingLeft),
-			t = px(n, s.paddingTop);
-		return {
-			l: l,
-			t: t,
-			w: l+px(n, s.paddingRight),
-			h: t+px(n, s.paddingBottom)
-		};
-	};
-
-	dojo._getBorderExtents = function(/*DomNode*/n, /*Object*/computedStyle){
-		//	summary:
-		//		returns an object with properties useful for noting the border
-		//		dimensions.
-		//	description:
-		// 		* l/t = the sum of left/top border (respectively)
-		//		* w = the sum of the left and right border
-		//		* h = the sum of the top and bottom border
-		//
-		//		The w/h are used for calculating boxes.
-		//		Normally application code will not need to invoke this
-		//		directly, and will use the ...box... functions instead.
-		var
-			ne = "none",
-			s = computedStyle||gcs(n),
-			bl = (s.borderLeftStyle != ne ? px(n, s.borderLeftWidth) : 0),
-			bt = (s.borderTopStyle != ne ? px(n, s.borderTopWidth) : 0);
-		return {
-			l: bl,
-			t: bt,
-			w: bl + (s.borderRightStyle!=ne ? px(n, s.borderRightWidth) : 0),
-			h: bt + (s.borderBottomStyle!=ne ? px(n, s.borderBottomWidth) : 0)
-		};
-	};
-
-	dojo._getPadBorderExtents = function(/*DomNode*/n, /*Object*/computedStyle){
-		//	summary:
-		//		Returns object with properties useful for box fitting with
-		//		regards to padding.
-		// description:
-		//		* l/t = the sum of left/top padding and left/top border (respectively)
-		//		* w = the sum of the left and right padding and border
-		//		* h = the sum of the top and bottom padding and border
-		//
-		//		The w/h are used for calculating boxes.
-		//		Normally application code will not need to invoke this
-		//		directly, and will use the ...box... functions instead.
-		var
-			s = computedStyle||gcs(n),
-			p = d._getPadExtents(n, s),
-			b = d._getBorderExtents(n, s);
-		return {
-			l: p.l + b.l,
-			t: p.t + b.t,
-			w: p.w + b.w,
-			h: p.h + b.h
-		};
-	};
-
-	dojo._getMarginExtents = function(n, computedStyle){
-		//	summary:
-		//		returns object with properties useful for box fitting with
-		//		regards to box margins (i.e., the outer-box).
-		//
-		//		* l/t = marginLeft, marginTop, respectively
-		//		* w = total width, margin inclusive
-		//		* h = total height, margin inclusive
-		//
-		//		The w/h are used for calculating boxes.
-		//		Normally application code will not need to invoke this
-		//		directly, and will use the ...box... functions instead.
-		var
-			s = computedStyle||gcs(n),
-			l = px(n, s.marginLeft),
-			t = px(n, s.marginTop),
-			r = px(n, s.marginRight),
-			b = px(n, s.marginBottom);
-		if(d.isWebKit && (s.position != "absolute")){
-			// FIXME: Safari's version of the computed right margin
-			// is the space between our right edge and the right edge
-			// of our offsetParent.
-			// What we are looking for is the actual margin value as
-			// determined by CSS.
-			// Hack solution is to assume left/right margins are the same.
-			r = l;
-		}
-		return {
-			l: l,
-			t: t,
-			w: l+r,
-			h: t+b
-		};
-	};
-
-	// Box getters work in any box context because offsetWidth/clientWidth
-	// are invariant wrt box context
-	//
-	// They do *not* work for display: inline objects that have padding styles
-	// because the user agent ignores padding (it's bogus styling in any case)
-	//
-	// Be careful with IMGs because they are inline or block depending on
-	// browser and browser mode.
-
-	// Although it would be easier to read, there are not separate versions of
-	// _getMarginBox for each browser because:
-	// 1. the branching is not expensive
-	// 2. factoring the shared code wastes cycles (function call overhead)
-	// 3. duplicating the shared code wastes bytes
-
-	dojo._getMarginBox = function(/*DomNode*/node, /*Object*/computedStyle){
-		// summary:
-		//		returns an object that encodes the width, height, left and top
-		//		positions of the node's margin box.
-		var s = computedStyle || gcs(node), me = d._getMarginExtents(node, s);
-		var l = node.offsetLeft - me.l, t = node.offsetTop - me.t, p = node.parentNode;
-				if(d.isMoz){
-			// Mozilla:
-			// If offsetParent has a computed overflow != visible, the offsetLeft is decreased
-			// by the parent's border.
-			// We don't want to compute the parent's style, so instead we examine node's
-			// computed left/top which is more stable.
-			var sl = parseFloat(s.left), st = parseFloat(s.top);
-			if(!isNaN(sl) && !isNaN(st)){
-				l = sl, t = st;
-			}else{
-				// If child's computed left/top are not parseable as a number (e.g. "auto"), we
-				// have no choice but to examine the parent's computed style.
-				if(p && p.style){
-					var pcs = gcs(p);
-					if(pcs.overflow != "visible"){
-						var be = d._getBorderExtents(p, pcs);
-						l += be.l, t += be.t;
-					}
-				}
-			}
-		}else if(d.isOpera || (d.isIE > 7 && !d.isQuirks)){
-			// On Opera and IE 8, offsetLeft/Top includes the parent's border
-			if(p){
-				be = d._getBorderExtents(p);
-				l -= be.l;
-				t -= be.t;
-			}
-		}
-				return {
-			l: l,
-			t: t,
-			w: node.offsetWidth + me.w,
-			h: node.offsetHeight + me.h
-		};
-	}
-	
-	dojo._getMarginSize = function(/*DomNode*/node, /*Object*/computedStyle){
-		// summary:
-		//	returns an object that encodes the width and height of
-		//	the node's margin box
-		node = byId(node);
-		var me = d._getMarginExtents(node, computedStyle || gcs(node));
-
-		var size = node.getBoundingClientRect();
-		return {
-			w: (size.right - size.left) + me.w,
-			h: (size.bottom - size.top) + me.h
-		}
-	}
-
-	dojo._getContentBox = function(node, computedStyle){
-		// summary:
-		//		Returns an object that encodes the width, height, left and top
-		//		positions of the node's content box, irrespective of the
-		//		current box model.
-
-		// clientWidth/Height are important since the automatically account for scrollbars
-		// fallback to offsetWidth/Height for special cases (see #3378)
-		var s = computedStyle || gcs(node),
-			pe = d._getPadExtents(node, s),
-			be = d._getBorderExtents(node, s),
-			w = node.clientWidth,
-			h
-		;
-		if(!w){
-			w = node.offsetWidth, h = node.offsetHeight;
-		}else{
-			h = node.clientHeight, be.w = be.h = 0;
-		}
-		// On Opera, offsetLeft includes the parent's border
-				if(d.isOpera){ pe.l += be.l; pe.t += be.t; };
-				return {
-			l: pe.l,
-			t: pe.t,
-			w: w - pe.w - be.w,
-			h: h - pe.h - be.h
-		};
-	};
-
-	dojo._getBorderBox = function(node, computedStyle){
-		var s = computedStyle || gcs(node),
-			pe = d._getPadExtents(node, s),
-			cb = d._getContentBox(node, s)
-		;
-		return {
-			l: cb.l - pe.l,
-			t: cb.t - pe.t,
-			w: cb.w + pe.w,
-			h: cb.h + pe.h
-		};
-	};
-
-	// Box setters depend on box context because interpretation of width/height styles
-	// vary wrt box context.
-	//
-	// The value of dojo.boxModel is used to determine box context.
-	// dojo.boxModel can be set directly to change behavior.
-	//
-	// Beware of display: inline objects that have padding styles
-	// because the user agent ignores padding (it's a bogus setup anyway)
-	//
-	// Be careful with IMGs because they are inline or block depending on
-	// browser and browser mode.
-	//
-	// Elements other than DIV may have special quirks, like built-in
-	// margins or padding, or values not detectable via computedStyle.
-	// In particular, margins on TABLE do not seems to appear
-	// at all in computedStyle on Mozilla.
-
-	dojo._setBox = function(/*DomNode*/node, /*Number?*/l, /*Number?*/t, /*Number?*/w, /*Number?*/h, /*String?*/u){
-		//	summary:
-		//		sets width/height/left/top in the current (native) box-model
-		//		dimentions. Uses the unit passed in u.
-		//	node:
-		//		DOM Node reference. Id string not supported for performance
-		//		reasons.
-		//	l:
-		//		left offset from parent.
-		//	t:
-		//		top offset from parent.
-		//	w:
-		//		width in current box model.
-		//	h:
-		//		width in current box model.
-		//	u:
-		//		unit measure to use for other measures. Defaults to "px".
-		u = u || "px";
-		var s = node.style;
-		if(!isNaN(l)){ s.left = l + u; }
-		if(!isNaN(t)){ s.top = t + u; }
-		if(w >= 0){ s.width = w + u; }
-		if(h >= 0){ s.height = h + u; }
-	};
-
-	dojo._isButtonTag = function(/*DomNode*/node) {
-		// summary:
-		//		True if the node is BUTTON or INPUT.type="button".
-		return node.tagName == "BUTTON"
-			|| node.tagName=="INPUT" && (node.getAttribute("type")||'').toUpperCase() == "BUTTON"; // boolean
-	};
-
-	dojo._usesBorderBox = function(/*DomNode*/node){
-		//	summary:
-		//		True if the node uses border-box layout.
-
-		// We could test the computed style of node to see if a particular box
-		// has been specified, but there are details and we choose not to bother.
-
-		// TABLE and BUTTON (and INPUT type=button) are always border-box by default.
-		// If you have assigned a different box to either one via CSS then
-		// box functions will break.
-
-		var n = node.tagName;
-		return d.boxModel=="border-box" || n=="TABLE" || d._isButtonTag(node); // boolean
-	};
-
-	dojo._setContentSize = function(/*DomNode*/node, /*Number*/widthPx, /*Number*/heightPx, /*Object*/computedStyle){
-		//	summary:
-		//		Sets the size of the node's contents, irrespective of margins,
-		//		padding, or borders.
-		if(d._usesBorderBox(node)){
-			var pb = d._getPadBorderExtents(node, computedStyle);
-			if(widthPx >= 0){ widthPx += pb.w; }
-			if(heightPx >= 0){ heightPx += pb.h; }
-		}
-		d._setBox(node, NaN, NaN, widthPx, heightPx);
-	};
-
-	dojo._setMarginBox = function(/*DomNode*/node, 	/*Number?*/leftPx, /*Number?*/topPx,
-													/*Number?*/widthPx, /*Number?*/heightPx,
-													/*Object*/computedStyle){
-		//	summary:
-		//		sets the size of the node's margin box and placement
-		//		(left/top), irrespective of box model. Think of it as a
-		//		passthrough to dojo._setBox that handles box-model vagaries for
-		//		you.
-
-		var s = computedStyle || gcs(node),
-		// Some elements have special padding, margin, and box-model settings.
-		// To use box functions you may need to set padding, margin explicitly.
-		// Controlling box-model is harder, in a pinch you might set dojo.boxModel.
-			bb = d._usesBorderBox(node),
-			pb = bb ? _nilExtents : d._getPadBorderExtents(node, s)
-		;
-		if(d.isWebKit){
-			// on Safari (3.1.2), button nodes with no explicit size have a default margin
-			// setting an explicit size eliminates the margin.
-			// We have to swizzle the width to get correct margin reading.
-			if(d._isButtonTag(node)){
-				var ns = node.style;
-				if(widthPx >= 0 && !ns.width) { ns.width = "4px"; }
-				if(heightPx >= 0 && !ns.height) { ns.height = "4px"; }
-			}
-		}
-		var mb = d._getMarginExtents(node, s);
-		if(widthPx >= 0){ widthPx = Math.max(widthPx - pb.w - mb.w, 0); }
-		if(heightPx >= 0){ heightPx = Math.max(heightPx - pb.h - mb.h, 0); }
-		d._setBox(node, leftPx, topPx, widthPx, heightPx);
-	};
-
-	var _nilExtents = { l:0, t:0, w:0, h:0 };
-
-	// public API
-
-	dojo.marginBox = function(/*DomNode|String*/node, /*Object?*/box){
-		//	summary:
-		//		Getter/setter for the margin-box of node.
-		//	description:
-		//		Getter/setter for the margin-box of node.
-		//		Returns an object in the expected format of box (regardless
-		//		if box is passed). The object might look like:
-		//			`{ l: 50, t: 200, w: 300: h: 150 }`
-		//		for a node offset from its parent 50px to the left, 200px from
-		//		the top with a margin width of 300px and a margin-height of
-		//		150px.
-		//	node:
-		//		id or reference to DOM Node to get/set box for
-		//	box:
-		//		If passed, denotes that dojo.marginBox() should
-		//		update/set the margin box for node. Box is an object in the
-		//		above format. All properties are optional if passed.
-		//	example:
-		//	Retrieve the marginbox of a passed node
-		//	|	var box = dojo.marginBox("someNodeId");
-		//	|	console.dir(box);
-		//
-		//	example:
-		//	Set a node's marginbox to the size of another node
-		//	|	var box = dojo.marginBox("someNodeId");
-		//	|	dojo.marginBox("someOtherNode", box);
-		
-		var n = byId(node), s = gcs(n), b = box;
-		return !b ? d._getMarginBox(n, s) : d._setMarginBox(n, b.l, b.t, b.w, b.h, s); // Object
-	};
-
-	dojo.contentBox = function(/*DomNode|String*/node, /*Object?*/box){
-		//	summary:
-		//		Getter/setter for the content-box of node.
-		//	description:
-		//		Returns an object in the expected format of box (regardless if box is passed).
-		//		The object might look like:
-		//			`{ l: 50, t: 200, w: 300: h: 150 }`
-		//		for a node offset from its parent 50px to the left, 200px from
-		//		the top with a content width of 300px and a content-height of
-		//		150px. Note that the content box may have a much larger border
-		//		or margin box, depending on the box model currently in use and
-		//		CSS values set/inherited for node.
-		//		While the getter will return top and left values, the
-		//		setter only accepts setting the width and height.
-		//	node:
-		//		id or reference to DOM Node to get/set box for
-		//	box:
-		//		If passed, denotes that dojo.contentBox() should
-		//		update/set the content box for node. Box is an object in the
-		//		above format, but only w (width) and h (height) are supported.
-		//		All properties are optional if passed.
-		var n = byId(node), s = gcs(n), b = box;
-		return !b ? d._getContentBox(n, s) : d._setContentSize(n, b.w, b.h, s); // Object
-	};
-
-	// =============================
-	// Positioning
-	// =============================
-
-	var _sumAncestorProperties = function(node, prop){
-		if(!(node = (node||0).parentNode)){return 0;}
-		var val, retVal = 0, _b = d.body();
-		while(node && node.style){
-			if(gcs(node).position == "fixed"){
-				return 0;
-			}
-			val = node[prop];
-			if(val){
-				retVal += val - 0;
-				// opera and khtml #body & #html has the same values, we only
-				// need one value
-				if(node == _b){ break; }
-			}
-			node = node.parentNode;
-		}
-		return retVal;	//	integer
-	};
-
-	dojo._docScroll = function(){
-		var n = d.global;
-		return "pageXOffset" in n
-			? { x:n.pageXOffset, y:n.pageYOffset }
-			: (n = d.isQuirks? d.doc.body : d.doc.documentElement, { x:d._fixIeBiDiScrollLeft(n.scrollLeft || 0), y:n.scrollTop || 0 });
-	};
-
-	dojo._isBodyLtr = function(){
-		return "_bodyLtr" in d? d._bodyLtr :
-			d._bodyLtr = (d.body().dir || d.doc.documentElement.dir || "ltr").toLowerCase() == "ltr"; // Boolean
-	};
-
-		dojo._getIeDocumentElementOffset = function(){
-		//	summary:
-		//		returns the offset in x and y from the document body to the
-		//		visual edge of the page
-		//	description:
-		// The following values in IE contain an offset:
-		//	|		event.clientX
-		//	|		event.clientY
-		//	|		node.getBoundingClientRect().left
-		//	|		node.getBoundingClientRect().top
-		//	 	But other position related values do not contain this offset,
-		//	 	such as node.offsetLeft, node.offsetTop, node.style.left and
-		//	 	node.style.top. The offset is always (2, 2) in LTR direction.
-		//	 	When the body is in RTL direction, the offset counts the width
-		//	 	of left scroll bar's width.  This function computes the actual
-		//	 	offset.
-
-		//NOTE: assumes we're being called in an IE browser
-
-		var de = d.doc.documentElement; // only deal with HTML element here, _abs handles body/quirks
-
-		if(d.isIE < 8){
-			var r = de.getBoundingClientRect(); // works well for IE6+
-			//console.debug('rect left,top = ' + r.left+','+r.top + ', html client left/top = ' + de.clientLeft+','+de.clientTop + ', rtl = ' + (!d._isBodyLtr()) + ', quirks = ' + d.isQuirks);
-			var l = r.left,
-			    t = r.top;
-			if(d.isIE < 7){
-				l += de.clientLeft;	// scrollbar size in strict/RTL, or,
-				t += de.clientTop;	// HTML border size in strict
-			}
-			return {
-				x: l < 0? 0 : l, // FRAME element border size can lead to inaccurate negative values
-				y: t < 0? 0 : t
-			};
-		}else{
-			return {
-				x: 0,
-				y: 0
-			};
-		}
-
-	};
-	
-	dojo._fixIeBiDiScrollLeft = function(/*Integer*/ scrollLeft){
-		// In RTL direction, scrollLeft should be a negative value, but IE
-		// returns a positive one. All codes using documentElement.scrollLeft
-		// must call this function to fix this error, otherwise the position
-		// will offset to right when there is a horizontal scrollbar.
-
-				var ie = d.isIE;
-		if(ie && !d._isBodyLtr()){
-			var qk = d.isQuirks,
-				de = qk ? d.doc.body : d.doc.documentElement;
-			if(ie == 6 && !qk && d.global.frameElement && de.scrollHeight > de.clientHeight){
-				scrollLeft += de.clientLeft; // workaround ie6+strict+rtl+iframe+vertical-scrollbar bug where clientWidth is too small by clientLeft pixels
-			}
-			return (ie < 8 || qk) ? (scrollLeft + de.clientWidth - de.scrollWidth) : -scrollLeft; // Integer
-		}
-				return scrollLeft; // Integer
-	};
-
-	// FIXME: need a setter for coords or a moveTo!!
-	dojo._abs = dojo.position = function(/*DomNode*/node, /*Boolean?*/includeScroll){
-		//	summary:
-		//		Gets the position and size of the passed element relative to
-		//		the viewport (if includeScroll==false), or relative to the
-		//		document root (if includeScroll==true).
-		//
-		//	description:
-		//		Returns an object of the form:
-		//			{ x: 100, y: 300, w: 20, h: 15 }
-		//		If includeScroll==true, the x and y values will include any
-		//		document offsets that may affect the position relative to the
-		//		viewport.
-		//		Uses the border-box model (inclusive of border and padding but
-		//		not margin).  Does not act as a setter.
-
-		node = byId(node);
-		var	db = d.body(),
-			dh = db.parentNode,
-			ret = node.getBoundingClientRect();
-			ret = { x: ret.left, y: ret.top, w: ret.right - ret.left, h: ret.bottom - ret.top };
-					if(d.isIE){
-				// On IE there's a 2px offset that we need to adjust for, see _getIeDocumentElementOffset()
-				var offset = d._getIeDocumentElementOffset();
-
-				// fixes the position in IE, quirks mode
-				ret.x -= offset.x + (d.isQuirks ? db.clientLeft+db.offsetLeft : 0);
-				ret.y -= offset.y + (d.isQuirks ? db.clientTop+db.offsetTop : 0);
-			}else if(d.isFF == 3){
-				// In FF3 you have to subtract the document element margins.
-				// Fixed in FF3.5 though.
-				var cs = gcs(dh);
-				ret.x -= px(dh, cs.marginLeft) + px(dh, cs.borderLeftWidth);
-				ret.y -= px(dh, cs.marginTop) + px(dh, cs.borderTopWidth);
-			}
-				// account for document scrolling
-		if(includeScroll){
-			var scroll = d._docScroll();
-			ret.x += scroll.x;
-			ret.y += scroll.y;
-		}
-
-		return ret; // Object
-	};
-
-	dojo.coords = function(/*DomNode|String*/node, /*Boolean?*/includeScroll){
-		//	summary:
-		//		Deprecated: Use position() for border-box x/y/w/h
-		//		or marginBox() for margin-box w/h/l/t.
-		//		Returns an object representing a node's size and position.
-		//
-		//	description:
-		//		Returns an object that measures margin-box (w)idth/(h)eight
-		//		and absolute position x/y of the border-box. Also returned
-		//		is computed (l)eft and (t)op values in pixels from the
-		//		node's offsetParent as returned from marginBox().
-		//		Return value will be in the form:
-		//|			{ l: 50, t: 200, w: 300: h: 150, x: 100, y: 300 }
-		//		Does not act as a setter. If includeScroll is passed, the x and
-		//		y params are affected as one would expect in dojo.position().
-		var n = byId(node), s = gcs(n), mb = d._getMarginBox(n, s);
-		var abs = d.position(n, includeScroll);
-		mb.x = abs.x;
-		mb.y = abs.y;
-		return mb;
-	};
-
-	// =============================
-	// Element attribute Functions
-	// =============================
-
-	// dojo.attr() should conform to http://www.w3.org/TR/DOM-Level-2-Core/
-
-	var _propNames = {
-			// properties renamed to avoid clashes with reserved words
-			"class":   "className",
-			"for":     "htmlFor",
-			// properties written as camelCase
-			tabindex:  "tabIndex",
-			readonly:  "readOnly",
-			colspan:   "colSpan",
-			frameborder: "frameBorder",
-			rowspan:   "rowSpan",
-			valuetype: "valueType"
-		},
-		_attrNames = {
-			// original attribute names
-			classname: "class",
-			htmlfor:   "for",
-			// for IE
-			tabindex:  "tabIndex",
-			readonly:  "readOnly"
-		},
-		_forcePropNames = {
-			innerHTML: 1,
-			className: 1,
-			htmlFor:   d.isIE,
-			value:     1
-		};
-
-	var _fixAttrName = function(/*String*/ name){
-		return _attrNames[name.toLowerCase()] || name;
-	};
-
-	var _hasAttr = function(node, name){
-		var attr = node.getAttributeNode && node.getAttributeNode(name);
-		return attr && attr.specified; // Boolean
-	};
-
-	// There is a difference in the presence of certain properties and their default values
-	// between browsers. For example, on IE "disabled" is present on all elements,
-	// but it is value is "false"; "tabIndex" of <div> returns 0 by default on IE, yet other browsers
-	// can return -1.
-
-	dojo.hasAttr = function(/*DomNode|String*/node, /*String*/name){
-		//	summary:
-		//		Returns true if the requested attribute is specified on the
-		//		given element, and false otherwise.
-		//	node:
-		//		id or reference to the element to check
-		//	name:
-		//		the name of the attribute
-		//	returns:
-		//		true if the requested attribute is specified on the
-		//		given element, and false otherwise
-		var lc = name.toLowerCase();
-		return _forcePropNames[_propNames[lc] || name] || _hasAttr(byId(node), _attrNames[lc] || name);	// Boolean
-	};
-
-	var _evtHdlrMap = {}, _ctr = 0,
-		_attrId = dojo._scopeName + "attrid",
-		// the next dictionary lists elements with read-only innerHTML on IE
-		_roInnerHtml = {col: 1, colgroup: 1,
-			// frameset: 1, head: 1, html: 1, style: 1,
-			table: 1, tbody: 1, tfoot: 1, thead: 1, tr: 1, title: 1};
-
-	dojo.attr = function(/*DomNode|String*/node, /*String|Object*/name, /*String?*/value){
-		//	summary:
-		//		Gets or sets an attribute on an HTML element.
-		//	description:
-		//		Handles normalized getting and setting of attributes on DOM
-		//		Nodes. If 2 arguments are passed, and a the second argumnt is a
-		//		string, acts as a getter.
-		//
-		//		If a third argument is passed, or if the second argument is a
-		//		map of attributes, acts as a setter.
-		//
-		//		When passing functions as values, note that they will not be
-		//		directly assigned to slots on the node, but rather the default
-		//		behavior will be removed and the new behavior will be added
-		//		using `dojo.connect()`, meaning that event handler properties
-		//		will be normalized and that some caveats with regards to
-		//		non-standard behaviors for onsubmit apply. Namely that you
-		//		should cancel form submission using `dojo.stopEvent()` on the
-		//		passed event object instead of returning a boolean value from
-		//		the handler itself.
-		//	node:
-		//		id or reference to the element to get or set the attribute on
-		//	name:
-		//		the name of the attribute to get or set.
-		//	value:
-		//		The value to set for the attribute
-		//	returns:
-		//		when used as a getter, the value of the requested attribute
-		//		or null if that attribute does not have a specified or
-		//		default value;
-		//
-		//		when used as a setter, the DOM node
-		//
-		//	example:
-		//	|	// get the current value of the "foo" attribute on a node
-		//	|	dojo.attr(dojo.byId("nodeId"), "foo");
-		//	|	// or we can just pass the id:
-		//	|	dojo.attr("nodeId", "foo");
-		//
-		//	example:
-		//	|	// use attr() to set the tab index
-		//	|	dojo.attr("nodeId", "tabIndex", 3);
-		//	|
-		//
-		//	example:
-		//	Set multiple values at once, including event handlers:
-		//	|	dojo.attr("formId", {
-		//	|		"foo": "bar",
-		//	|		"tabIndex": -1,
-		//	|		"method": "POST",
-		//	|		"onsubmit": function(e){
-		//	|			// stop submitting the form. Note that the IE behavior
-		//	|			// of returning true or false will have no effect here
-		//	|			// since our handler is connect()ed to the built-in
-		//	|			// onsubmit behavior and so we need to use
-		//	|			// dojo.stopEvent() to ensure that the submission
-		//	|			// doesn't proceed.
-		//	|			dojo.stopEvent(e);
-		//	|
-		//	|			// submit the form with Ajax
-		//	|			dojo.xhrPost({ form: "formId" });
-		//	|		}
-		//	|	});
-		//
-		//	example:
-		//	Style is s special case: Only set with an object hash of styles
-		//	|	dojo.attr("someNode",{
-		//	|		id:"bar",
-		//	|		style:{
-		//	|			width:"200px", height:"100px", color:"#000"
-		//	|		}
-		//	|	});
-		//
-		//	example:
-		//	Again, only set style as an object hash of styles:
-		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
-		//	|	dojo.attr("someNode", "style", obj);
-		//	|
-		//	|	// though shorter to use `dojo.style()` in this case:
-		//	|	dojo.style("someNode", obj);
-
-		node = byId(node);
-		var args = arguments.length, prop;
-		if(args == 2 && typeof name != "string"){ // inline'd type check
-			// the object form of setter: the 2nd argument is a dictionary
-			for(var x in name){
-				d.attr(node, x, name[x]);
-			}
-			return node; // DomNode
-		}
-		var lc = name.toLowerCase(),
-			propName = _propNames[lc] || name,
-			forceProp = _forcePropNames[propName],
-			attrName = _attrNames[lc] || name;
-		if(args == 3){
-			// setter
-			do{
-				if(propName == "style" && typeof value != "string"){ // inline'd type check
-					// special case: setting a style
-					d.style(node, value);
-					break;
-				}
-				if(propName == "innerHTML"){
-					// special case: assigning HTML
-										if(d.isIE && node.tagName.toLowerCase() in _roInnerHtml){
-						d.empty(node);
-						node.appendChild(d._toDom(value, node.ownerDocument));
-					}else{
-											node[propName] = value;
-										}
-										break;
-				}
-				if(d.isFunction(value)){
-					// special case: assigning an event handler
-					// clobber if we can
-					var attrId = d.attr(node, _attrId);
-					if(!attrId){
-						attrId = _ctr++;
-						d.attr(node, _attrId, attrId);
-					}
-					if(!_evtHdlrMap[attrId]){
-						_evtHdlrMap[attrId] = {};
-					}
-					var h = _evtHdlrMap[attrId][propName];
-					if(h){
-						d.disconnect(h);
-					}else{
-						try{
-							delete node[propName];
-						}catch(e){}
-					}
-					// ensure that event objects are normalized, etc.
-					_evtHdlrMap[attrId][propName] = d.connect(node, propName, value);
-					break;
-				}
-				if(forceProp || typeof value == "boolean"){
-					// special case: forcing assignment to the property
-					// special case: setting boolean to a property instead of attribute
-					node[propName] = value;
-					break;
-				}
-				// node's attribute
-				node.setAttribute(attrName, value);
-			}while(false);
-			return node; // DomNode
-		}
-		// getter
-		// should we access this attribute via a property or
-		// via getAttribute()?
-		value = node[propName];
-		if(forceProp && typeof value != "undefined"){
-			// node's property
-			return value;	// Anything
-		}
-		if(propName != "href" && (typeof value == "boolean" || d.isFunction(value))){
-			// node's property
-			return value;	// Anything
-		}
-		// node's attribute
-		// we need _hasAttr() here to guard against IE returning a default value
-		return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything
-	};
-
-	dojo.removeAttr = function(/*DomNode|String*/ node, /*String*/ name){
-		//	summary:
-		//		Removes an attribute from an HTML element.
-		//	node:
-		//		id or reference to the element to remove the attribute from
-		//	name:
-		//		the name of the attribute to remove
-		byId(node).removeAttribute(_fixAttrName(name));
-	};
-
-	dojo.getNodeProp = function(/*DomNode|String*/ node, /*String*/ name){
-		//	summary:
-		//		Returns an effective value of a property or an attribute.
-		//	node:
-		//		id or reference to the element to remove the attribute from
-		//	name:
-		//		the name of the attribute
-		node = byId(node);
-		var lc = name.toLowerCase(),
-			propName = _propNames[lc] || name;
-		if((propName in node) && propName != "href"){
-			// node's property
-			return node[propName];	// Anything
-		}
-		// node's attribute
-		var attrName = _attrNames[lc] || name;
-		return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything
-	};
-
-	dojo.create = function(tag, attrs, refNode, pos){
-		//	summary:
-		//		Create an element, allowing for optional attribute decoration
-		//		and placement.
-		//
-		// description:
-		//		A DOM Element creation function. A shorthand method for creating a node or
-		//		a fragment, and allowing for a convenient optional attribute setting step,
-		//		as well as an optional DOM placement reference.
-		//|
-		//		Attributes are set by passing the optional object through `dojo.attr`.
-		//		See `dojo.attr` for noted caveats and nuances, and API if applicable.
-		//|
-		//		Placement is done via `dojo.place`, assuming the new node to be the action
-		//		node, passing along the optional reference node and position.
-		//
-		// tag: String|DomNode
-		//		A string of the element to create (eg: "div", "a", "p", "li", "script", "br"),
-		//		or an existing DOM node to process.
-		//
-		// attrs: Object
-		//		An object-hash of attributes to set on the newly created node.
-		//		Can be null, if you don't want to set any attributes/styles.
-		//		See: `dojo.attr` for a description of available attributes.
-		//
-		// refNode: String?|DomNode?
-		//		Optional reference node. Used by `dojo.place` to place the newly created
-		//		node somewhere in the dom relative to refNode. Can be a DomNode reference
-		//		or String ID of a node.
-		//
-		// pos: String?
-		//		Optional positional reference. Defaults to "last" by way of `dojo.place`,
-		//		though can be set to "first","after","before","last", "replace" or "only"
-		//		to further control the placement of the new node relative to the refNode.
-		//		'refNode' is required if a 'pos' is specified.
-		//
-		// returns: DomNode
-		//
-		// example:
-		//	Create a DIV:
-		//	|	var n = dojo.create("div");
-		//
-		// example:
-		//	Create a DIV with content:
-		//	|	var n = dojo.create("div", { innerHTML:"<p>hi</p>" });
-		//
-		// example:
-		//	Place a new DIV in the BODY, with no attributes set
-		//	|	var n = dojo.create("div", null, dojo.body());
-		//
-		// example:
-		//	Create an UL, and populate it with LI's. Place the list as the first-child of a
-		//	node with id="someId":
-		//	|	var ul = dojo.create("ul", null, "someId", "first");
-		//	|	var items = ["one", "two", "three", "four"];
-		//	|	dojo.forEach(items, function(data){
-		//	|		dojo.create("li", { innerHTML: data }, ul);
-		//	|	});
-		//
-		// example:
-		//	Create an anchor, with an href. Place in BODY:
-		//	|	dojo.create("a", { href:"foo.html", title:"Goto FOO!" }, dojo.body());
-		//
-		// example:
-		//	Create a `dojo.NodeList()` from a new element (for syntatic sugar):
-		//	|	dojo.query(dojo.create('div'))
-		//	|		.addClass("newDiv")
-		//	|		.onclick(function(e){ console.log('clicked', e.target) })
-		//	|		.place("#someNode"); // redundant, but cleaner.
-
-		var doc = d.doc;
-		if(refNode){
-			refNode = byId(refNode);
-			doc = refNode.ownerDocument;
-		}
-		if(typeof tag == "string"){ // inline'd type check
-			tag = doc.createElement(tag);
-		}
-		if(attrs){ d.attr(tag, attrs); }
-		if(refNode){ d.place(tag, refNode, pos); }
-		return tag; // DomNode
-	};
-
-	/*=====
-	dojo.empty = function(node){
-			//	summary:
-			//		safely removes all children of the node.
-			//	node: DOMNode|String
-			//		a reference to a DOM node or an id.
-			//	example:
-			//	Destroy node's children byId:
-			//	|	dojo.empty("someId");
-			//
-			//	example:
-			//	Destroy all nodes' children in a list by reference:
-			//	|	dojo.query(".someNode").forEach(dojo.empty);
-	}
-	=====*/
-
-	d.empty =
-				d.isIE ?  function(node){
-			node = byId(node);
-			for(var c; c = node.lastChild;){ // intentional assignment
-				d.destroy(c);
-			}
-		} :
-				function(node){
-			byId(node).innerHTML = "";
-		};
-
-	/*=====
-	dojo._toDom = function(frag, doc){
-			//	summary:
-			//		instantiates an HTML fragment returning the corresponding DOM.
-			//	frag: String
-			//		the HTML fragment
-			//	doc: DocumentNode?
-			//		optional document to use when creating DOM nodes, defaults to
-			//		dojo.doc if not specified.
-			//	returns: DocumentFragment
-			//
-			//	example:
-			//	Create a table row:
-			//	|	var tr = dojo._toDom("<tr><td>First!</td></tr>");
-	}
-	=====*/
-
-	// support stuff for dojo._toDom
-	var tagWrap = {
-			option: ["select"],
-			tbody: ["table"],
-			thead: ["table"],
-			tfoot: ["table"],
-			tr: ["table", "tbody"],
-			td: ["table", "tbody", "tr"],
-			th: ["table", "thead", "tr"],
-			legend: ["fieldset"],
-			caption: ["table"],
-			colgroup: ["table"],
-			col: ["table", "colgroup"],
-			li: ["ul"]
-		},
-		reTag = /<\s*([\w\:]+)/,
-		masterNode = {}, masterNum = 0,
-		masterName = "__" + d._scopeName + "ToDomId";
-
-	// generate start/end tag strings to use
-	// for the injection for each special tag wrap case.
-	for(var param in tagWrap){
-		if(tagWrap.hasOwnProperty(param)){
-			var tw = tagWrap[param];
-			tw.pre  = param == "option" ? '<select multiple="multiple">' : "<" + tw.join("><") + ">";
-			tw.post = "</" + tw.reverse().join("></") + ">";
-			// the last line is destructive: it reverses the array,
-			// but we don't care at this point
-		}
-	}
-
-	d._toDom = function(frag, doc){
-		//	summary:
-		// 		converts HTML string into DOM nodes.
-
-		doc = doc || d.doc;
-		var masterId = doc[masterName];
-		if(!masterId){
-			doc[masterName] = masterId = ++masterNum + "";
-			masterNode[masterId] = doc.createElement("div");
-		}
-
-		// make sure the frag is a string.
-		frag += "";
-
-		// find the starting tag, and get node wrapper
-		var match = frag.match(reTag),
-			tag = match ? match[1].toLowerCase() : "",
-			master = masterNode[masterId],
-			wrap, i, fc, df;
-		if(match && tagWrap[tag]){
-			wrap = tagWrap[tag];
-			master.innerHTML = wrap.pre + frag + wrap.post;
-			for(i = wrap.length; i; --i){
-				master = master.firstChild;
-			}
-		}else{
-			master.innerHTML = frag;
-		}
-
-		// one node shortcut => return the node itself
-		if(master.childNodes.length == 1){
-			return master.removeChild(master.firstChild); // DOMNode
-		}
-
-		// return multiple nodes as a document fragment
-		df = doc.createDocumentFragment();
-		while(fc = master.firstChild){ // intentional assignment
-			df.appendChild(fc);
-		}
-		return df; // DOMNode
-	};
-
-	// =============================
-	// (CSS) Class Functions
-	// =============================
-	var _className = "className";
-
-	dojo.hasClass = function(/*DomNode|String*/node, /*String*/classStr){
-		//	summary:
-		//		Returns whether or not the specified classes are a portion of the
-		//		class list currently applied to the node.
-		//
-		//	node:
-		//		String ID or DomNode reference to check the class for.
-		//
-		//	classStr:
-		//		A string class name to look for.
-		//
-		//	example:
-		//	Do something if a node with id="someNode" has class="aSillyClassName" present
-		//	|	if(dojo.hasClass("someNode","aSillyClassName")){ ... }
-
-		return ((" "+ byId(node)[_className] +" ").indexOf(" " + classStr + " ") >= 0);  // Boolean
-	};
-
-	var spaces = /\s+/, a1 = [""],
-		fakeNode = {},
-		str2array = function(s){
-			if(typeof s == "string" || s instanceof String){
-				if(s.indexOf(" ") < 0){
-					a1[0] = s;
-					return a1;
-				}else{
-					return s.split(spaces);
-				}
-			}
-			// assumed to be an array
-			return s || "";
-		};
-
-	dojo.addClass = function(/*DomNode|String*/node, /*String|Array*/classStr){
-		//	summary:
-		//		Adds the specified classes to the end of the class list on the
-		//		passed node. Will not re-apply duplicate classes.
-		//
-		//	node:
-		//		String ID or DomNode reference to add a class string too
-		//
-		//	classStr:
-		//		A String class name to add, or several space-separated class names,
-		//		or an array of class names.
-		//
-		// example:
-		//	Add a class to some node:
-		//	|	dojo.addClass("someNode", "anewClass");
-		//
-		// example:
-		//	Add two classes at once:
-		//	|	dojo.addClass("someNode", "firstClass secondClass");
-		//
-		// example:
-		//	Add two classes at once (using array):
-		//	|	dojo.addClass("someNode", ["firstClass", "secondClass"]);
-		//
-		// example:
-		//	Available in `dojo.NodeList` for multiple additions
-		//	|	dojo.query("ul > li").addClass("firstLevel");
-
-		node = byId(node);
-		classStr = str2array(classStr);
-		var cls = node[_className], oldLen;
-		cls = cls ? " " + cls + " " : " ";
-		oldLen = cls.length;
-		for(var i = 0, len = classStr.length, c; i < len; ++i){
-			c = classStr[i];
-			if(c && cls.indexOf(" " + c + " ") < 0){
-				cls += c + " ";
-			}
-		}
-		if(oldLen < cls.length){
-			node[_className] = cls.substr(1, cls.length - 2);
-		}
-	};
-
-	dojo.removeClass = function(/*DomNode|String*/node, /*String|Array?*/classStr){
-		// summary:
-		//		Removes the specified classes from node. No `dojo.hasClass`
-		//		check is required.
-		//
-		// node:
-		// 		String ID or DomNode reference to remove the class from.
-		//
-		// classStr:
-		//		An optional String class name to remove, or several space-separated
-		//		class names, or an array of class names. If omitted, all class names
-		//		will be deleted.
-		//
-		// example:
-		//	Remove a class from some node:
-		//	|	dojo.removeClass("someNode", "firstClass");
-		//
-		// example:
-		//	Remove two classes from some node:
-		//	|	dojo.removeClass("someNode", "firstClass secondClass");
-		//
-		// example:
-		//	Remove two classes from some node (using array):
-		//	|	dojo.removeClass("someNode", ["firstClass", "secondClass"]);
-		//
-		// example:
-		//	Remove all classes from some node:
-		//	|	dojo.removeClass("someNode");
-		//
-		// example:
-		//	Available in `dojo.NodeList()` for multiple removal
-		//	|	dojo.query(".foo").removeClass("foo");
-
-		node = byId(node);
-		var cls;
-		if(classStr !== undefined){
-			classStr = str2array(classStr);
-			cls = " " + node[_className] + " ";
-			for(var i = 0, len = classStr.length; i < len; ++i){
-				cls = cls.replace(" " + classStr[i] + " ", " ");
-			}
-			cls = d.trim(cls);
-		}else{
-			cls = "";
-		}
-		if(node[_className] != cls){ node[_className] = cls; }
-	};
-
-	dojo.replaceClass = function(/*DomNode|String*/node, /*String|Array*/addClassStr, /*String|Array?*/removeClassStr){
-		// summary:
-		//		Replaces one or more classes on a node if not present.
-		//		Operates more quickly than calling dojo.removeClass and dojo.addClass
-		// node:
-		// 		String ID or DomNode reference to remove the class from.
-		// addClassStr:
-		//		A String class name to add, or several space-separated class names,
-		//		or an array of class names.
-		// removeClassStr:
-		//		A String class name to remove, or several space-separated class names,
-		//		or an array of class names.
-		//
-		// example:
-		//	|	dojo.replaceClass("someNode", "add1 add2", "remove1 remove2");
-		//
-		// example:
-		//	Replace all classes with addMe
-		//	|	dojo.replaceClass("someNode", "addMe");
-		//
-		// example:
-		//	Available in `dojo.NodeList()` for multiple toggles
-		//	|	dojo.query(".findMe").replaceClass("addMe", "removeMe");
-
-        node = byId(node);
-		fakeNode.className = node.className;
-		dojo.removeClass(fakeNode, removeClassStr);
-		dojo.addClass(fakeNode, addClassStr);
-		if(node.className !== fakeNode.className){
-			node.className = fakeNode.className;
-		}
-	};
-
-	dojo.toggleClass = function(/*DomNode|String*/node, /*String|Array*/classStr, /*Boolean?*/condition){
-		//	summary:
-		//		Adds a class to node if not present, or removes if present.
-		//		Pass a boolean condition if you want to explicitly add or remove.
-		//	condition:
-		//		If passed, true means to add the class, false means to remove.
-		//
-		// example:
-		//	|	dojo.toggleClass("someNode", "hovered");
-		//
-		// example:
-		//	Forcefully add a class
-		//	|	dojo.toggleClass("someNode", "hovered", true);
-		//
-		// example:
-		//	Available in `dojo.NodeList()` for multiple toggles
-		//	|	dojo.query(".toggleMe").toggleClass("toggleMe");
-
-		if(condition === undefined){
-			condition = !d.hasClass(node, classStr);
-		}
-		d[condition ? "addClass" : "removeClass"](node, classStr);
-	};
-
-})();
-
-}
+//>>built
+define("dojo/_base/html",["./kernel","../dom","../dom-style","../dom-attr","../dom-prop","../dom-class","../dom-construct","../dom-geometry"],function(_1,_2,_3,_4,_5,_6,_7,_8){_1.byId=_2.byId;_1.isDescendant=_2.isDescendant;_1.setSelectable=_2.setSelectable;_1.getAttr=_4.get;_1.setAttr=_4.set;_1.hasAttr=_4.has;_1.removeAttr=_4.remove;_1.getNodeProp=_4.getNodeProp;_1.attr=function(_9,_a,_b){if(arguments.length==2){return _4[typeof _a=="string"?"get":"set"](_9,_a);}return _4.set(_9,_a,_b);};_1.hasClass=_6.contains;_1.addClass=_6.add;_1.removeClass=_6.remove;_1.toggleClass=_6.toggle;_1.replaceClass=_6.replace;_1._toDom=_1.toDom=_7.toDom;_1.place=_7.place;_1.create=_7.create;_1.empty=function(_c){_7.empty(_c);};_1._destroyElement=_1.destroy=function(_d){_7.destroy(_d);};_1._getPadExtents=_1.getPadExtents=_8.getPadExtents;_1._getBorderExtents=_1.getBorderExtents=_8.getBorderExtents;_1._getPadBorderExtents=_1.getPadBorderExtents=_8.getPadBorderExtents;_1._getMarginExtents=_1.getMarginExtents=_8.getMarginExtents;_1._getMarginSize=_1.getMarginSize=_8.getMarginSize;_1._getMarginBox=_1.getMarginBox=_8.getMarginBox;_1.setMarginBox=_8.setMarginBox;_1._getContentBox=_1.getContentBox=_8.getContentBox;_1.setContentSize=_8.setContentSize;_1._isBodyLtr=_1.isBodyLtr=_8.isBodyLtr;_1._docScroll=_1.docScroll=_8.docScroll;_1._getIeDocumentElementOffset=_1.getIeDocumentElementOffset=_8.getIeDocumentElementOffset;_1._fixIeBiDiScrollLeft=_1.fixIeBiDiScrollLeft=_8.fixIeBiDiScrollLeft;_1.position=_8.position;_1.marginBox=function marginBox(_e,_f){return _f?_8.setMarginBox(_e,_f):_8.getMarginBox(_e);};_1.contentBox=function contentBox(_10,box){return box?_8.setContentSize(_10,box):_8.getContentBox(_10);};_1.coords=function(_11,_12){_1.deprecated("dojo.coords()","Use dojo.position() or dojo.marginBox().");_11=_2.byId(_11);var s=_3.getComputedStyle(_11),mb=_8.getMarginBox(_11,s);var abs=_8.position(_11,_12);mb.x=abs.x;mb.y=abs.y;return mb;};_1.getProp=_5.get;_1.setProp=_5.set;_1.prop=function(_13,_14,_15){if(arguments.length==2){return _5[typeof _14=="string"?"get":"set"](_13,_14);}return _5.set(_13,_14,_15);};_1.getStyle=_3.get;_1.setStyle=_3.set;_1.getComputedStyle=_3.getComputedStyle;_1.__toPixelValue=_1.toPixelValue=_3.toPixelValue;_1.style=function(_16,_17,_18){switch(arguments.length){case 1:return _3.get(_16);case 2:return _3[typeof _17=="string"?"get":"set"](_16,_17);}return _3.set(_16,_17,_18);};return _1;});
\ No newline at end of file
diff --git a/lib/dojo/_base/html.js.uncompressed.js b/lib/dojo/_base/html.js.uncompressed.js
new file mode 100644
index 000000000..63e3bee46
--- /dev/null
+++ b/lib/dojo/_base/html.js.uncompressed.js
@@ -0,0 +1,389 @@
+define("dojo/_base/html", ["./kernel", "../dom", "../dom-style", "../dom-attr", "../dom-prop", "../dom-class", "../dom-construct", "../dom-geometry"], function(dojo, dom, style, attr, prop, cls, ctr, geom){
+	// module:
+	//		dojo/dom
+	// summary:
+	//		This module is a stub for the core dojo DOM API.
+
+	// mix-in dom
+	dojo.byId = dom.byId;
+	dojo.isDescendant = dom.isDescendant;
+	dojo.setSelectable = dom.setSelectable;
+
+	// mix-in dom-attr
+	dojo.getAttr = attr.get;
+	dojo.setAttr = attr.set;
+	dojo.hasAttr = attr.has;
+	dojo.removeAttr = attr.remove;
+	dojo.getNodeProp = attr.getNodeProp;
+
+	dojo.attr = function(node, name, value){
+		// summary:
+		//		Gets or sets an attribute on an HTML element.
+		// description:
+		//		Handles normalized getting and setting of attributes on DOM
+		//		Nodes. If 2 arguments are passed, and a the second argument is a
+		//		string, acts as a getter.
+		//
+		//		If a third argument is passed, or if the second argument is a
+		//		map of attributes, acts as a setter.
+		//
+		//		When passing functions as values, note that they will not be
+		//		directly assigned to slots on the node, but rather the default
+		//		behavior will be removed and the new behavior will be added
+		//		using `dojo.connect()`, meaning that event handler properties
+		//		will be normalized and that some caveats with regards to
+		//		non-standard behaviors for onsubmit apply. Namely that you
+		//		should cancel form submission using `dojo.stopEvent()` on the
+		//		passed event object instead of returning a boolean value from
+		//		the handler itself.
+		// node: DOMNode|String
+		//		id or reference to the element to get or set the attribute on
+		// name: String|Object
+		//		the name of the attribute to get or set.
+		// value: String?
+		//		The value to set for the attribute
+		// returns:
+		//		when used as a getter, the value of the requested attribute
+		//		or null if that attribute does not have a specified or
+		//		default value;
+		//
+		//		when used as a setter, the DOM node
+		//
+		// example:
+		//	|	// get the current value of the "foo" attribute on a node
+		//	|	dojo.attr(dojo.byId("nodeId"), "foo");
+		//	|	// or we can just pass the id:
+		//	|	dojo.attr("nodeId", "foo");
+		//
+		// example:
+		//	|	// use attr() to set the tab index
+		//	|	dojo.attr("nodeId", "tabIndex", 3);
+		//	|
+		//
+		// example:
+		//	Set multiple values at once, including event handlers:
+		//	|	dojo.attr("formId", {
+		//	|		"foo": "bar",
+		//	|		"tabIndex": -1,
+		//	|		"method": "POST",
+		//	|		"onsubmit": function(e){
+		//	|			// stop submitting the form. Note that the IE behavior
+		//	|			// of returning true or false will have no effect here
+		//	|			// since our handler is connect()ed to the built-in
+		//	|			// onsubmit behavior and so we need to use
+		//	|			// dojo.stopEvent() to ensure that the submission
+		//	|			// doesn't proceed.
+		//	|			dojo.stopEvent(e);
+		//	|
+		//	|			// submit the form with Ajax
+		//	|			dojo.xhrPost({ form: "formId" });
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Style is s special case: Only set with an object hash of styles
+		//	|	dojo.attr("someNode",{
+		//	|		id:"bar",
+		//	|		style:{
+		//	|			width:"200px", height:"100px", color:"#000"
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Again, only set style as an object hash of styles:
+		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
+		//	|	dojo.attr("someNode", "style", obj);
+		//	|
+		//	|	// though shorter to use `dojo.style()` in this case:
+		//	|	dojo.style("someNode", obj);
+
+		if(arguments.length == 2){
+			return attr[typeof name == "string" ? "get" : "set"](node, name);
+		}
+		return attr.set(node, name, value);
+	};
+
+	// mix-in dom-class
+	dojo.hasClass = cls.contains;
+	dojo.addClass = cls.add;
+	dojo.removeClass = cls.remove;
+	dojo.toggleClass = cls.toggle;
+	dojo.replaceClass = cls.replace;
+
+	// mix-in dom-construct
+	dojo._toDom = dojo.toDom = ctr.toDom;
+	dojo.place = ctr.place;
+	dojo.create = ctr.create;
+	dojo.empty = function(node){ ctr.empty(node); };
+	dojo._destroyElement = dojo.destroy = function(node){ ctr.destroy(node); };
+
+	// mix-in dom-geometry
+	dojo._getPadExtents = dojo.getPadExtents = geom.getPadExtents;
+	dojo._getBorderExtents = dojo.getBorderExtents = geom.getBorderExtents;
+	dojo._getPadBorderExtents = dojo.getPadBorderExtents = geom.getPadBorderExtents;
+	dojo._getMarginExtents = dojo.getMarginExtents = geom.getMarginExtents;
+	dojo._getMarginSize = dojo.getMarginSize = geom.getMarginSize;
+	dojo._getMarginBox = dojo.getMarginBox = geom.getMarginBox;
+	dojo.setMarginBox = geom.setMarginBox;
+	dojo._getContentBox = dojo.getContentBox = geom.getContentBox;
+	dojo.setContentSize = geom.setContentSize;
+	dojo._isBodyLtr = dojo.isBodyLtr = geom.isBodyLtr;
+	dojo._docScroll = dojo.docScroll = geom.docScroll;
+	dojo._getIeDocumentElementOffset = dojo.getIeDocumentElementOffset = geom.getIeDocumentElementOffset;
+	dojo._fixIeBiDiScrollLeft = dojo.fixIeBiDiScrollLeft = geom.fixIeBiDiScrollLeft;
+	dojo.position = geom.position;
+
+	dojo.marginBox = function marginBox(/*DomNode|String*/node, /*Object?*/box){
+		// summary:
+		//		Getter/setter for the margin-box of node.
+		// description:
+		//		Getter/setter for the margin-box of node.
+		//		Returns an object in the expected format of box (regardless
+		//		if box is passed). The object might look like:
+		//			`{ l: 50, t: 200, w: 300: h: 150 }`
+		//		for a node offset from its parent 50px to the left, 200px from
+		//		the top with a margin width of 300px and a margin-height of
+		//		150px.
+		// node:
+		//		id or reference to DOM Node to get/set box for
+		// box:
+		//		If passed, denotes that dojo.marginBox() should
+		//		update/set the margin box for node. Box is an object in the
+		//		above format. All properties are optional if passed.
+		// example:
+		//		Retrieve the margin box of a passed node
+		//	|	var box = dojo.marginBox("someNodeId");
+		//	|	console.dir(box);
+		//
+		// example:
+		//		Set a node's margin box to the size of another node
+		//	|	var box = dojo.marginBox("someNodeId");
+		//	|	dojo.marginBox("someOtherNode", box);
+		return box ? geom.setMarginBox(node, box) : geom.getMarginBox(node); // Object
+	};
+
+	dojo.contentBox = function contentBox(/*DomNode|String*/node, /*Object?*/box){
+		// summary:
+		//		Getter/setter for the content-box of node.
+		// description:
+		//		Returns an object in the expected format of box (regardless if box is passed).
+		//		The object might look like:
+		//			`{ l: 50, t: 200, w: 300: h: 150 }`
+		//		for a node offset from its parent 50px to the left, 200px from
+		//		the top with a content width of 300px and a content-height of
+		//		150px. Note that the content box may have a much larger border
+		//		or margin box, depending on the box model currently in use and
+		//		CSS values set/inherited for node.
+		//		While the getter will return top and left values, the
+		//		setter only accepts setting the width and height.
+		// node:
+		//		id or reference to DOM Node to get/set box for
+		// box:
+		//		If passed, denotes that dojo.contentBox() should
+		//		update/set the content box for node. Box is an object in the
+		//		above format, but only w (width) and h (height) are supported.
+		//		All properties are optional if passed.
+		return box ? geom.setContentSize(node, box) : geom.getContentBox(node); // Object
+	};
+
+	dojo.coords = function(/*DomNode|String*/node, /*Boolean?*/includeScroll){
+		// summary:
+		//		Deprecated: Use position() for border-box x/y/w/h
+		//		or marginBox() for margin-box w/h/l/t.
+		//		Returns an object representing a node's size and position.
+		//
+		// description:
+		//		Returns an object that measures margin-box (w)idth/(h)eight
+		//		and absolute position x/y of the border-box. Also returned
+		//		is computed (l)eft and (t)op values in pixels from the
+		//		node's offsetParent as returned from marginBox().
+		//		Return value will be in the form:
+		//|			{ l: 50, t: 200, w: 300: h: 150, x: 100, y: 300 }
+		//		Does not act as a setter. If includeScroll is passed, the x and
+		//		y params are affected as one would expect in dojo.position().
+		dojo.deprecated("dojo.coords()", "Use dojo.position() or dojo.marginBox().");
+		node = dom.byId(node);
+		var s = style.getComputedStyle(node), mb = geom.getMarginBox(node, s);
+		var abs = geom.position(node, includeScroll);
+		mb.x = abs.x;
+		mb.y = abs.y;
+		return mb;	// Object
+	};
+
+	// mix-in dom-prop
+	dojo.getProp = prop.get;
+	dojo.setProp = prop.set;
+
+	dojo.prop = function(/*DomNode|String*/node, /*String|Object*/name, /*String?*/value){
+		// summary:
+		//		Gets or sets a property on an HTML element.
+		// description:
+		//		Handles normalized getting and setting of properties on DOM
+		//		Nodes. If 2 arguments are passed, and a the second argument is a
+		//		string, acts as a getter.
+		//
+		//		If a third argument is passed, or if the second argument is a
+		//		map of attributes, acts as a setter.
+		//
+		//		When passing functions as values, note that they will not be
+		//		directly assigned to slots on the node, but rather the default
+		//		behavior will be removed and the new behavior will be added
+		//		using `dojo.connect()`, meaning that event handler properties
+		//		will be normalized and that some caveats with regards to
+		//		non-standard behaviors for onsubmit apply. Namely that you
+		//		should cancel form submission using `dojo.stopEvent()` on the
+		//		passed event object instead of returning a boolean value from
+		//		the handler itself.
+		// node:
+		//		id or reference to the element to get or set the property on
+		// name:
+		//		the name of the property to get or set.
+		// value:
+		//		The value to set for the property
+		// returns:
+		//		when used as a getter, the value of the requested property
+		//		or null if that attribute does not have a specified or
+		//		default value;
+		//
+		//		when used as a setter, the DOM node
+		//
+		// example:
+		//	|	// get the current value of the "foo" property on a node
+		//	|	dojo.prop(dojo.byId("nodeId"), "foo");
+		//	|	// or we can just pass the id:
+		//	|	dojo.prop("nodeId", "foo");
+		//
+		// example:
+		//	|	// use prop() to set the tab index
+		//	|	dojo.prop("nodeId", "tabIndex", 3);
+		//	|
+		//
+		// example:
+		//	Set multiple values at once, including event handlers:
+		//	|	dojo.prop("formId", {
+		//	|		"foo": "bar",
+		//	|		"tabIndex": -1,
+		//	|		"method": "POST",
+		//	|		"onsubmit": function(e){
+		//	|			// stop submitting the form. Note that the IE behavior
+		//	|			// of returning true or false will have no effect here
+		//	|			// since our handler is connect()ed to the built-in
+		//	|			// onsubmit behavior and so we need to use
+		//	|			// dojo.stopEvent() to ensure that the submission
+		//	|			// doesn't proceed.
+		//	|			dojo.stopEvent(e);
+		//	|
+		//	|			// submit the form with Ajax
+		//	|			dojo.xhrPost({ form: "formId" });
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Style is s special case: Only set with an object hash of styles
+		//	|	dojo.prop("someNode",{
+		//	|		id:"bar",
+		//	|		style:{
+		//	|			width:"200px", height:"100px", color:"#000"
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Again, only set style as an object hash of styles:
+		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
+		//	|	dojo.prop("someNode", "style", obj);
+		//	|
+		//	|	// though shorter to use `dojo.style()` in this case:
+		//	|	dojo.style("someNode", obj);
+
+		if(arguments.length == 2){
+			return prop[typeof name == "string" ? "get" : "set"](node, name);
+		}
+		// setter
+		return prop.set(node, name, value);
+	};
+
+	// mix-in dom-style
+	dojo.getStyle = style.get;
+	dojo.setStyle = style.set;
+	dojo.getComputedStyle = style.getComputedStyle;
+	dojo.__toPixelValue = dojo.toPixelValue = style.toPixelValue;
+
+	dojo.style = function(node, name, value){
+		// summary:
+		//		Accesses styles on a node. If 2 arguments are
+		//		passed, acts as a getter. If 3 arguments are passed, acts
+		//		as a setter.
+		// description:
+		//		Getting the style value uses the computed style for the node, so the value
+		//		will be a calculated value, not just the immediate node.style value.
+		//		Also when getting values, use specific style names,
+		//		like "borderBottomWidth" instead of "border" since compound values like
+		//		"border" are not necessarily reflected as expected.
+		//		If you want to get node dimensions, use `dojo.marginBox()`,
+		//		`dojo.contentBox()` or `dojo.position()`.
+		// node: DOMNode|String
+		//		id or reference to node to get/set style for
+		// name: String?|Object?
+		//		the style property to set in DOM-accessor format
+		//		("borderWidth", not "border-width") or an object with key/value
+		//		pairs suitable for setting each property.
+		// value: String?
+		//		If passed, sets value on the node for style, handling
+		//		cross-browser concerns.  When setting a pixel value,
+		//		be sure to include "px" in the value. For instance, top: "200px".
+		//		Otherwise, in some cases, some browsers will not apply the style.
+		// returns:
+		//		when used as a getter, return the computed style of the node if passing in an ID or node,
+		//		or return the normalized, computed value for the property when passing in a node and a style property
+		// example:
+		//		Passing only an ID or node returns the computed style object of
+		//		the node:
+		//	|	dojo.style("thinger");
+		// example:
+		//		Passing a node and a style property returns the current
+		//		normalized, computed value for that property:
+		//	|	dojo.style("thinger", "opacity"); // 1 by default
+		//
+		// example:
+		//		Passing a node, a style property, and a value changes the
+		//		current display of the node and returns the new computed value
+		//	|	dojo.style("thinger", "opacity", 0.5); // == 0.5
+		//
+		// example:
+		//		Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node:
+		//	|	dojo.style("thinger", {
+		//	|		"opacity": 0.5,
+		//	|		"border": "3px solid black",
+		//	|		"height": "300px"
+		//	|	});
+		//
+		// example:
+		//		When the CSS style property is hyphenated, the JavaScript property is camelCased.
+		//		font-size becomes fontSize, and so on.
+		//	|	dojo.style("thinger",{
+		//	|		fontSize:"14pt",
+		//	|		letterSpacing:"1.2em"
+		//	|	});
+		//
+		// example:
+		//		dojo.NodeList implements .style() using the same syntax, omitting the "node" parameter, calling
+		//		dojo.style() on every element of the list. See: `dojo.query()` and `dojo.NodeList()`
+		//	|	dojo.query(".someClassName").style("visibility","hidden");
+		//	|	// or
+		//	|	dojo.query("#baz > div").style({
+		//	|		opacity:0.75,
+		//	|		fontSize:"13pt"
+		//	|	});
+
+		switch(arguments.length){
+			case 1:
+				return style.get(node);
+			case 2:
+				return style[typeof name == "string" ? "get" : "set"](node, name);
+		}
+		// setter
+		return style.set(node, name, value);
+	};
+
+	return dojo;
+});
diff --git a/lib/dojo/_base/json.js b/lib/dojo/_base/json.js
index 4267c225e..b644339f7 100644
--- a/lib/dojo/_base/json.js
+++ b/lib/dojo/_base/json.js
@@ -4,152 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.json"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.json"] = true;
-dojo.provide("dojo._base.json");
-
-
-dojo.fromJson = function(/*String*/ json){
-	// summary:
-	// 		Parses a [JSON](http://json.org) string to return a JavaScript object.
-	// description:
-	// 		Throws for invalid JSON strings, but it does not use a strict JSON parser. It
-	// 		delegates to eval().  The content passed to this method must therefore come
-	//		from a trusted source.
-	// json:
-	//		a string literal of a JSON item, for instance:
-	//			`'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`
-
-	return eval("(" + json + ")"); // Object
-};
-
-dojo._escapeString = function(/*String*/str){
-	//summary:
-	//		Adds escape sequences for non-visual characters, double quote and
-	//		backslash and surrounds with double quotes to form a valid string
-	//		literal.
-	return ('"' + str.replace(/(["\\])/g, '\\$1') + '"').
-		replace(/[\f]/g, "\\f").replace(/[\b]/g, "\\b").replace(/[\n]/g, "\\n").
-		replace(/[\t]/g, "\\t").replace(/[\r]/g, "\\r"); // string
-};
-
-dojo.toJsonIndentStr = "\t";
-dojo.toJson = function(/*Object*/ it, /*Boolean?*/ prettyPrint, /*String?*/ _indentStr){
-	//	summary:
-	//		Returns a [JSON](http://json.org) serialization of an object.
-	//	description:
-	//		Returns a [JSON](http://json.org) serialization of an object.
-	//		Note that this doesn't check for infinite recursion, so don't do that!
-	//	it:
-	//		an object to be serialized. Objects may define their own
-	//		serialization via a special "__json__" or "json" function
-	//		property. If a specialized serializer has been defined, it will
-	//		be used as a fallback.
-	//	prettyPrint:
-	//		if true, we indent objects and arrays to make the output prettier.
-	//		The variable `dojo.toJsonIndentStr` is used as the indent string --
-	//		to use something other than the default (tab), change that variable
-	//		before calling dojo.toJson().
-	//	_indentStr:
-	//		private variable for recursive calls when pretty printing, do not use.
-	//	example:
-	//		simple serialization of a trivial object
-	//		|	var jsonStr = dojo.toJson({ howdy: "stranger!", isStrange: true });
-	//		|	doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr);
-	//	example:
-	//		a custom serializer for an objects of a particular class:
-	//		|	dojo.declare("Furby", null, {
-	//		|		furbies: "are strange",
-	//		|		furbyCount: 10,
-	//		|		__json__: function(){
-	//		|		},
-	//		|	});
-
-	if(it === undefined){
-		return "undefined";
-	}
-	var objtype = typeof it;
-	if(objtype == "number" || objtype == "boolean"){
-		return it + "";
-	}
-	if(it === null){
-		return "null";
-	}
-	if(dojo.isString(it)){
-		return dojo._escapeString(it);
-	}
-	// recurse
-	var recurse = arguments.callee;
-	// short-circuit for objects that support "json" serialization
-	// if they return "self" then just pass-through...
-	var newObj;
-	_indentStr = _indentStr || "";
-	var nextIndent = prettyPrint ? _indentStr + dojo.toJsonIndentStr : "";
-	var tf = it.__json__||it.json;
-	if(dojo.isFunction(tf)){
-		newObj = tf.call(it);
-		if(it !== newObj){
-			return recurse(newObj, prettyPrint, nextIndent);
-		}
-	}
-	if(it.nodeType && it.cloneNode){ // isNode
-		// we can't seriailize DOM nodes as regular objects because they have cycles
-		// DOM nodes could be serialized with something like outerHTML, but
-		// that can be provided by users in the form of .json or .__json__ function.
-		throw new Error("Can't serialize DOM nodes");
-	}
-
-	var sep = prettyPrint ? " " : "";
-	var newLine = prettyPrint ? "\n" : "";
-
-	// array
-	if(dojo.isArray(it)){
-		var res = dojo.map(it, function(obj){
-			var val = recurse(obj, prettyPrint, nextIndent);
-			if(typeof val != "string"){
-				val = "undefined";
-			}
-			return newLine + nextIndent + val;
-		});
-		return "[" + res.join("," + sep) + newLine + _indentStr + "]";
-	}
-	/*
-	// look in the registry
-	try {
-		window.o = it;
-		newObj = dojo.json.jsonRegistry.match(it);
-		return recurse(newObj, prettyPrint, nextIndent);
-	}catch(e){
-		// console.log(e);
-	}
-	// it's a function with no adapter, skip it
-	*/
-	if(objtype == "function"){
-		return null; // null
-	}
-	// generic object code path
-	var output = [], key;
-	for(key in it){
-		var keyStr, val;
-		if(typeof key == "number"){
-			keyStr = '"' + key + '"';
-		}else if(typeof key == "string"){
-			keyStr = dojo._escapeString(key);
-		}else{
-			// skip non-string or number keys
-			continue;
-		}
-		val = recurse(it[key], prettyPrint, nextIndent);
-		if(typeof val != "string"){
-			// skip non-serializable values
-			continue;
-		}
-		// FIXME: use += on Moz!!
-		//	 MOW NOTE: using += is a pain because you have to account for the dangling comma...
-		output.push(newLine + nextIndent + keyStr + ":" + sep + val);
-	}
-	return "{" + output.join("," + sep) + newLine + _indentStr + "}"; // String
-};
-
-}
+//>>built
+define("dojo/_base/json",["./kernel","../json"],function(_1,_2){_1.fromJson=function(js){return eval("("+js+")");};_1._escapeString=_2.stringify;_1.toJsonIndentStr="\t";_1.toJson=function(it,_3){return _2.stringify(it,function(_4,_5){if(_5){var tf=_5.__json__||_5.json;if(typeof tf=="function"){return tf.call(_5);}}return _5;},_3&&_1.toJsonIndentStr);};return _1;});
\ No newline at end of file
diff --git a/lib/dojo/_base/json.js.uncompressed.js b/lib/dojo/_base/json.js.uncompressed.js
new file mode 100644
index 000000000..b70d4ebb8
--- /dev/null
+++ b/lib/dojo/_base/json.js.uncompressed.js
@@ -0,0 +1,85 @@
+define("dojo/_base/json", ["./kernel", "../json"], function(dojo, json){
+  // module:
+  //    dojo/_base/json
+  // summary:
+  //    This module defines the dojo JSON API.
+
+dojo.fromJson = function(/*String*/ js){
+	// summary:
+	//		Parses a JavaScript expression and returns a JavaScript value.
+	// description:
+	//		Throws for invalid JavaScript expressions. It does not use a strict JSON parser. It
+	//		always delegates to eval(). The content passed to this method must therefore come
+	//		from a trusted source.
+	//		It is recommend that you use dojo/json's parse function for an
+	//		implementation uses the (faster) native JSON parse when available.
+	// js:
+	//		a string literal of a JavaScript expression, for instance:
+	//			`'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`
+
+	return eval("(" + js + ")"); // Object
+};
+
+/*=====
+dojo._escapeString = function(){
+	// summary:
+	//		Adds escape sequences for non-visual characters, double quote and
+	//		backslash and surrounds with double quotes to form a valid string
+	//		literal.
+};
+=====*/
+dojo._escapeString = json.stringify; // just delegate to json.stringify
+
+dojo.toJsonIndentStr = "\t";
+dojo.toJson = function(/*Object*/ it, /*Boolean?*/ prettyPrint){
+	// summary:
+	//		Returns a [JSON](http://json.org) serialization of an object.
+	// description:
+	//		Returns a [JSON](http://json.org) serialization of an object.
+	//		Note that this doesn't check for infinite recursion, so don't do that!
+	//		It is recommend that you use dojo/json's stringify function for an lighter
+	//		and faster implementation that matches the native JSON API and uses the
+	//		native JSON serializer when available.
+	// it:
+	//		an object to be serialized. Objects may define their own
+	//		serialization via a special "__json__" or "json" function
+	//		property. If a specialized serializer has been defined, it will
+	//		be used as a fallback.
+	//		Note that in 1.6, toJson would serialize undefined, but this no longer supported
+	//		since it is not supported by native JSON serializer.
+	// prettyPrint:
+	//		if true, we indent objects and arrays to make the output prettier.
+	//		The variable `dojo.toJsonIndentStr` is used as the indent string --
+	//		to use something other than the default (tab), change that variable
+	//		before calling dojo.toJson().
+	//		Note that if native JSON support is available, it will be used for serialization,
+	//		and native implementations vary on the exact spacing used in pretty printing.
+	// returns:
+	// 		A JSON string serialization of the passed-in object.
+	// example:
+	//		simple serialization of a trivial object
+	//		|	var jsonStr = dojo.toJson({ howdy: "stranger!", isStrange: true });
+	//		|	doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr);
+	// example:
+	//		a custom serializer for an objects of a particular class:
+	//		|	dojo.declare("Furby", null, {
+	//		|		furbies: "are strange",
+	//		|		furbyCount: 10,
+	//		|		__json__: function(){
+	//		|		},
+	//		|	});
+
+	// use dojo/json
+	return json.stringify(it, function(key, value){
+		if(value){
+			var tf = value.__json__||value.json;
+			if(typeof tf == "function"){
+				return tf.call(value);
+			}
+		}
+		return value;
+	}, prettyPrint && dojo.toJsonIndentStr);	// String
+};
+
+return dojo;
+});
diff --git a/lib/dojo/_base/kernel.js b/lib/dojo/_base/kernel.js
new file mode 100644
index 000000000..f574dadd2
--- /dev/null
+++ b/lib/dojo/_base/kernel.js
@@ -0,0 +1,8 @@
+/*
+	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
+*/
+
+//>>built
+define("dojo/_base/kernel",["../has","./config","require","module"],function(_1,_2,_3,_4){var i,p,_5={},_6={},_7={config:_2,global:this,dijit:_5,dojox:_6};var _8={dojo:["dojo",_7],dijit:["dijit",_5],dojox:["dojox",_6]},_9=(_3.packs&&_3.packs[_4.id.match(/[^\/]+/)[0]].packageMap)||{},_a;for(p in _9){if(_8[p]){_8[p][0]=_9[p];}else{_8[p]=[_9[p],{}];}}for(p in _8){_a=_8[p];_a[1]._scopeName=_a[0];if(!_2.noGlobals){this[_a[0]]=_a[1];}}_7.scopeMap=_8;_7.baseUrl=_7.config.baseUrl=_3.baseUrl;_7.isAsync=!1||_3.async;_7.locale=_2.locale;var _b="$Rev: 28982 $".match(/\d+/);_7.version={major:1,minor:7,patch:3,flag:"",revision:_b?+_b[0]:NaN,toString:function(){var v=_7.version;return v.major+"."+v.minor+"."+v.patch+v.flag+" ("+v.revision+")";}};true||_1.add("extend-dojo",1);_7.eval=function(_c){};(Function("d","d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(_7);if(0){_7.exit=function(_d){quit(_d);};}else{_7.exit=function(){};}true||_1.add("dojo-guarantee-console",1);if(1){typeof console!="undefined"||(console={});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 _e=tn+"";console[_e]=("log" in console)?function(){var a=Array.apply({},arguments);a.unshift(_e+":");console["log"](a.join(" "));}:function(){};console[_e]._fake=true;})();}}}_1.add("dojo-debug-messages",!!_2.isDebug);if(_1("dojo-debug-messages")){_7.deprecated=function(_f,_10,_11){var _12="DEPRECATED: "+_f;if(_10){_12+=" "+_10;}if(_11){_12+=" -- will be removed in version: "+_11;}console.warn(_12);};_7.experimental=function(_13,_14){var _15="EXPERIMENTAL: "+_13+" -- APIs subject to change without notice.";if(_14){_15+=" "+_14;}console.warn(_15);};}else{_7.deprecated=_7.experimental=function(){};}true||_1.add("dojo-modulePaths",1);if(1){if(_2.modulePaths){_7.deprecated("dojo.modulePaths","use paths configuration");var _16={};for(p in _2.modulePaths){_16[p.replace(/\./g,"/")]=_2.modulePaths[p];}_3({paths:_16});}}true||_1.add("dojo-moduleUrl",1);if(1){_7.moduleUrl=function(_17,url){_7.deprecated("dojo.moduleUrl()","use require.toUrl","2.0");var _18=null;if(_17){_18=_3.toUrl(_17.replace(/\./g,"/")+(url?("/"+url):"")+"/*.*").replace(/\/\*\.\*/,"")+(url?"":"/");}return _18;};}_7._hasResource={};return _7;});
\ No newline at end of file
diff --git a/lib/dojo/_base/kernel.js.uncompressed.js b/lib/dojo/_base/kernel.js.uncompressed.js
new file mode 100644
index 000000000..30465dbb1
--- /dev/null
+++ b/lib/dojo/_base/kernel.js.uncompressed.js
@@ -0,0 +1,302 @@
+define("dojo/_base/kernel", ["../has", "./config", "require", "module"], function(has, config, require, module){
+	// module:
+	//		dojo/_base/kernel
+	// summary:
+	//		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 = {
+			// 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 dojo packageMap configuration variable which relocates packages to different names. 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.packs && require.packs[module.id.match(/[^\/]+/)[0]].packageMap) || {},
+
+		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;
+
+	// 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;
+
+	/*=====
+		dojo.version = function(){
+			// summary:
+			//		Version number of the Dojo Toolkit
+			// 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
+			this.major = 0;
+			this.minor = 0;
+			this.patch = 0;
+			this.flag = "";
+			this.revision = 0;
+		}
+	=====*/
+	var rev = "$Rev: 28982 $".match(/\d+/);
+	dojo.version = {
+		major: 1, minor: 7, patch: 3, 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.
+	true || has.add("extend-dojo", 1);
+
+
+	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`
+	};
+
+	(Function("d", "d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo);
+
+
+	if(0){
+		dojo.exit = function(exitcode){
+			quit(exitcode);
+		};
+	} else{
+		dojo.exit = function(){
+		};
+	}
+
+	true || 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
+	);
+	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);
+		};
+	}else{
+		dojo.deprecated = dojo.experimental =  function(){};
+	}
+
+	true || 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});
+		}
+	}
+
+	true || 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;
+});
diff --git a/lib/dojo/_base/lang.js b/lib/dojo/_base/lang.js
index 9061de01e..bc88c7cde 100644
--- a/lib/dojo/_base/lang.js
+++ b/lib/dojo/_base/lang.js
@@ -4,394 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.lang"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.lang"] = true;
-dojo.provide("dojo._base.lang");
-
-
-(function(){
-	var d = dojo, opts = Object.prototype.toString;
-
-	// Crockford (ish) functions
-
-	dojo.isString = function(/*anything*/ it){
-		//	summary:
-		//		Return true if it is a String
-		return (typeof it == "string" || it instanceof String); // Boolean
-	};
-
-	dojo.isArray = function(/*anything*/ it){
-		//	summary:
-		//		Return true if it is an Array.
-		//		Does not work on Arrays created in other windows.
-		return it && (it instanceof Array || typeof it == "array"); // Boolean
-	};
-
-	dojo.isFunction = function(/*anything*/ it){
-		// summary:
-		//		Return true if it is a Function
-		return opts.call(it) === "[object Function]";
-	};
-
-	dojo.isObject = function(/*anything*/ it){
-		// summary:
-		//		Returns true if it is a JavaScript object (or an Array, a Function
-		//		or null)
-		return it !== undefined &&
-			(it === null || typeof it == "object" || d.isArray(it) || d.isFunction(it)); // Boolean
-	};
-
-	dojo.isArrayLike = function(/*anything*/ it){
-		//	summary:
-		//		similar to dojo.isArray() but more permissive
-		//	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
-		//		dojo.isArrayLike(), but will return false when passed to
-		//		dojo.isArray().
-		//	returns:
-		//		If it walks like a duck and quacks like a duck, return `true`
-		return it && it !== undefined && // Boolean
-			// keep out built-in constructors (Number, String, ...) which have length
-			// properties
-			!d.isString(it) && !d.isFunction(it) &&
-			!(it.tagName && it.tagName.toLowerCase() == 'form') &&
-			(d.isArray(it) || isFinite(it.length));
-	};
-
-	dojo.isAlien = function(/*anything*/ 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 && !d.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
-	};
-
-	dojo.extend = function(/*Object*/ constructor, /*Object...*/ props){
-		// summary:
-		//		Adds all properties and methods of props to constructor's
-		//		prototype, making them available to all instances created with
-		//		constructor.
-		for(var i=1, l=arguments.length; i<l; i++){
-			d._mixin(constructor.prototype, arguments[i]);
-		}
-		return constructor; // Object
-	};
-
-	dojo._hitchArgs = function(scope, method /*,...*/){
-		var pre = d._toArray(arguments, 2);
-		var named = d.isString(method);
-		return function(){
-			// arrayify arguments
-			var args = d._toArray(arguments);
-			// locate our method
-			var f = named ? (scope||d.global)[method] : method;
-			// invoke with collected args
-			return f && f.apply(scope || this, pre.concat(args)); // mixed
-		}; // Function
-	};
-
-	dojo.hitch = function(/*Object*/scope, /*Function|String*/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:
-		//		The scope to use when method executes. If method is a string,
-		//		scope is also the object containing method.
-		//	method:
-		//		A function to be hitched to scope, or the name of the method in
-		//		scope to be hitched.
-		//	example:
-		//	|	dojo.hitch(foo, "bar")();
-		//		runs foo.bar() in the scope of foo
-		//	example:
-		//	|	dojo.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 = dojo.hitch(foo, "bar", 1, 2);
-		//	|	fn(3); // logs "1, 2, 3"
-		//	example:
-		//	|	var foo = { bar: 2 };
-		//	|	dojo.hitch(foo, function(){ this.bar = 10; })();
-		//		execute an anonymous function in scope of foo
-		
-		if(arguments.length > 2){
-			return d._hitchArgs.apply(d, arguments); // Function
-		}
-		if(!method){
-			method = scope;
-			scope = null;
-		}
-		if(d.isString(method)){
-			scope = scope || d.global;
-			if(!scope[method]){ throw(['dojo.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
-	};
-
-	/*=====
-	dojo.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 implementaton 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:
-		//		The object to delegate to for properties not found directly on the
-		//		return object or in props.
-		//	props:
-		//		an object containing properties to assign to the returned object
-		//	returns:
-		//		an Object of anonymous type
-		//	example:
-		//	|	var foo = { bar: "baz" };
-		//	|	var thinger = dojo.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
-	}
-	=====*/
-
-	dojo.delegate = dojo._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){
-				d._mixin(tmp, props);
-			}
-			return tmp; // Object
-		};
-	})();
-
-	/*=====
-	dojo._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.
-	}
-	=====*/
-
-	var efficient = function(obj, offset, startWith){
-		return (startWith||[]).concat(Array.prototype.slice.call(obj, offset||0));
-	};
-
-		var slow = function(obj, offset, startWith){
-		var arr = startWith||[];
-		for(var x = offset || 0; x < obj.length; x++){
-			arr.push(obj[x]);
-		}
-		return arr;
-	};
-	
-	dojo._toArray =
-				d.isIE ?  function(obj){
-			return ((obj.item) ? slow : efficient).apply(this, arguments);
-		} :
-				efficient;
-
-	dojo.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 dojo.partial is the functional equivalent of calling:
-		//		|	dojo.hitch(null, funcName, ...);
-		var arr = [ null ];
-		return d.hitch.apply(d, arr.concat(d._toArray(arguments))); // Function
-	};
-
-	var extraNames = d._extraNames, extraLen = extraNames.length, empty = {};
-
-	dojo.clone = function(/*anything*/ o){
-		// summary:
-		//		Clones objects (including DOM nodes) and all children.
-		//		Warning: do not clone cyclic structures.
-		if(!o || typeof o != "object" || d.isFunction(o)){
-			// null, undefined, any non-object, or function
-			return o;	// anything
-		}
-		if(o.nodeType && "cloneNode" in o){
-			// DOM Node
-			return o.cloneNode(true); // Node
-		}
-		if(o instanceof Date){
-			// Date
-			return new Date(o.getTime());	// Date
-		}
-		if(o instanceof RegExp){
-			// RegExp
-			return new RegExp(o);   // RegExp
-		}
-		var r, i, l, s, name;
-		if(d.isArray(o)){
-			// array
-			r = [];
-			for(i = 0, l = o.length; i < l; ++i){
-				if(i in o){
-					r.push(d.clone(o[i]));
-				}
-			}
-// we don't clone functions for performance reasons
-//		}else if(d.isFunction(o)){
-//			// function
-//			r = function(){ return o.apply(this, arguments); };
-		}else{
-			// generic objects
-			r = o.constructor ? new o.constructor() : {};
-		}
-		for(name in o){
-			// the "tobj" condition avoid copying properties in "source"
-			// inherited from Object.prototype.  For example, if target has a custom
-			// toString() method, don't overwrite it with the toString() method
-			// that source inherited from Object.prototype
-			s = o[name];
-			if(!(name in r) || (r[name] !== s && (!(name in empty) || empty[name] !== s))){
-				r[name] = d.clone(s);
-			}
-		}
-				// IE doesn't recognize some custom functions in for..in
-		if(extraLen){
-			for(i = 0; i < extraLen; ++i){
-				name = extraNames[i];
-				s = o[name];
-				if(!(name in r) || (r[name] !== s && (!(name in empty) || empty[name] !== s))){
-					r[name] = s; // functions only, we don't clone them
-				}
-			}
-		}
-				return r; // Object
-	};
-
-	/*=====
-	dojo.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
-		//		dojo.string.trim()
-		return "";	// String
-	}
-	=====*/
-
-	dojo.trim = String.prototype.trim ?
-		function(str){ return str.trim(); } :
-		function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); };
-
-	/*=====
-	dojo.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:
-		//	|	dojo.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:
-		//	|	dojo.replace("Hello, {0} {2}!",
-		//	|	  ["Robert", "X", "Cringely"]);
-		//	|	// returns: Hello, Robert Cringely!
-		//	example:
-		//	|	// uses a function for substitutions:
-		//	|	function sum(a){
-		//	|	  var t = 0;
-		//	|	  dojo.forEach(a, function(x){ t += x; });
-		//	|	  return t;
-		//	|	}
-		//	|	dojo.replace(
-		//	|	  "{count} payments averaging {avg} USD per payment.",
-		//	|	  dojo.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:
-		//	|	dojo.replace("Hello, ${0} ${2}!",
-		//	|	  ["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g);
-		//	|	// returns: Hello, Robert Cringely!
-		return "";	// String
-	}
-	=====*/
-
-	var _pattern = /\{([^\}]+)\}/g;
-	dojo.replace = function(tmpl, map, pattern){
-		return tmpl.replace(pattern || _pattern, d.isFunction(map) ?
-			map : function(_, k){ return d.getObject(k, false, map); });
-	};
-})();
-
-}
+//>>built
+define("dojo/_base/lang",["./kernel","../has","./sniff"],function(_1,_2){_2.add("bug-for-in-skips-shadowed",function(){for(var i in {toString:1}){return 0;}return 1;});var _3=_2("bug-for-in-skips-shadowed")?"hasOwnProperty.valueOf.isPrototypeOf.propertyIsEnumerable.toLocaleString.toString.constructor".split("."):[],_4=_3.length,_5=function(_6,_7,_8){var _9,s,i,_a={};for(_9 in _7){s=_7[_9];if(!(_9 in _6)||(_6[_9]!==s&&(!(_9 in _a)||_a[_9]!==s))){_6[_9]=_8?_8(s):s;}}if(_2("bug-for-in-skips-shadowed")){if(_7){for(i=0;i<_4;++i){_9=_3[i];s=_7[_9];if(!(_9 in _6)||(_6[_9]!==s&&(!(_9 in _a)||_a[_9]!==s))){_6[_9]=_8?_8(s):s;}}}}return _6;},_b=function(_c,_d){if(!_c){_c={};}for(var i=1,l=arguments.length;i<l;i++){_e._mixin(_c,arguments[i]);}return _c;},_f=function(_10,_11,_12){var p,i=0,_13=_1.global;if(!_12){if(!_10.length){return _13;}else{p=_10[i++];try{_12=_1.scopeMap[p]&&_1.scopeMap[p][1];}catch(e){}_12=_12||(p in _13?_13[p]:(_11?_13[p]={}:undefined));}}while(_12&&(p=_10[i++])){_12=(p in _12?_12[p]:(_11?_12[p]={}:undefined));}return _12;},_14=function(_15,_16,_17){var _18=_15.split("."),p=_18.pop(),obj=_f(_18,true,_17);return obj&&p?(obj[p]=_16):undefined;},_19=function(_1a,_1b,_1c){return _f(_1a.split("."),_1b,_1c);},_1d=function(_1e,obj){return _e.getObject(_1e,false,obj)!==undefined;},_1f=Object.prototype.toString,_20=function(it){return (typeof it=="string"||it instanceof String);},_21=function(it){return it&&(it instanceof Array||typeof it=="array");},_22=function(it){return _1f.call(it)==="[object Function]";},_23=function(it){return it!==undefined&&(it===null||typeof it=="object"||_e.isArray(it)||_e.isFunction(it));},_24=function(it){return it&&it!==undefined&&!_e.isString(it)&&!_e.isFunction(it)&&!(it.tagName&&it.tagName.toLowerCase()=="form")&&(_e.isArray(it)||isFinite(it.length));},_25=function(it){return it&&!_e.isFunction(it)&&/\{\s*\[native code\]\s*\}/.test(String(it));},_26=function(_27,_28){for(var i=1,l=arguments.length;i<l;i++){_e._mixin(_27.prototype,arguments[i]);}return _27;},_29=function(_2a,_2b){var pre=_2c(arguments,2);var _2d=_e.isString(_2b);return function(){var _2e=_2c(arguments);var f=_2d?(_2a||_1.global)[_2b]:_2b;return f&&f.apply(_2a||this,pre.concat(_2e));};},_2f=function(_30,_31){if(arguments.length>2){return _e._hitchArgs.apply(_1,arguments);}if(!_31){_31=_30;_30=null;}if(_e.isString(_31)){_30=_30||_1.global;if(!_30[_31]){throw (["dojo.hitch: scope[\"",_31,"\"] is null (scope=\"",_30,"\")"].join(""));}return function(){return _30[_31].apply(_30,arguments||[]);};}return !_30?_31:function(){return _31.apply(_30,arguments||[]);};},_32=(function(){function TMP(){};return function(obj,_33){TMP.prototype=obj;var tmp=new TMP();TMP.prototype=null;if(_33){_e._mixin(tmp,_33);}return tmp;};})(),_34=function(obj,_35,_36){return (_36||[]).concat(Array.prototype.slice.call(obj,_35||0));},_2c=_2("ie")?(function(){function _37(obj,_38,_39){var arr=_39||[];for(var x=_38||0;x<obj.length;x++){arr.push(obj[x]);}return arr;};return function(obj){return ((obj.item)?_37:_34).apply(this,arguments);};})():_34,_3a=function(_3b){var arr=[null];return _e.hitch.apply(_1,arr.concat(_e._toArray(arguments)));},_3c=function(src){if(!src||typeof src!="object"||_e.isFunction(src)){return src;}if(src.nodeType&&"cloneNode" in src){return src.cloneNode(true);}if(src instanceof Date){return new Date(src.getTime());}if(src instanceof RegExp){return new RegExp(src);}var r,i,l;if(_e.isArray(src)){r=[];for(i=0,l=src.length;i<l;++i){if(i in src){r.push(_3c(src[i]));}}}else{r=src.constructor?new src.constructor():{};}return _e._mixin(r,src,_3c);},_3d=String.prototype.trim?function(str){return str.trim();}:function(str){return str.replace(/^\s\s*/,"").replace(/\s\s*$/,"");},_3e=/\{([^\}]+)\}/g,_3f=function(_40,map,_41){return _40.replace(_41||_3e,_e.isFunction(map)?map:function(_42,k){return _19(k,false,map);});},_e={_extraNames:_3,_mixin:_5,mixin:_b,setObject:_14,getObject:_19,exists:_1d,isString:_20,isArray:_21,isFunction:_22,isObject:_23,isArrayLike:_24,isAlien:_25,extend:_26,_hitchArgs:_29,hitch:_2f,delegate:_32,_toArray:_2c,partial:_3a,clone:_3c,trim:_3d,replace:_3f};1&&_b(_1,_e);return _e;});
\ No newline at end of file
diff --git a/lib/dojo/_base/lang.js.uncompressed.js b/lib/dojo/_base/lang.js.uncompressed.js
new file mode 100644
index 000000000..503606040
--- /dev/null
+++ b/lib/dojo/_base/lang.js.uncompressed.js
@@ -0,0 +1,707 @@
+define("dojo/_base/lang", ["./kernel", "../has", "./sniff"], function(dojo, has){
+	//	module:
+	//		dojo/_base/lang
+	//	summary:
+	//		This module defines Javascript language extensions.
+
+	has.add("bug-for-in-skips-shadowed", function(){
+		// if true, the for-in interator skips object properties that exist in Object's prototype (IE 6 - ?)
+		for(var i in {toString: 1}){
+			return 0;
+		}
+		return 1;
+	});
+
+	var _extraNames =
+			has("bug-for-in-skips-shadowed") ?
+				"hasOwnProperty.valueOf.isPrototypeOf.propertyIsEnumerable.toLocaleString.toString.constructor".split(".") : [],
+
+		_extraLen = _extraNames.length,
+
+		_mixin = function(dest, source, copyFunc){
+			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){
+			if(!dest){ dest = {}; }
+			for(var i = 1, l = arguments.length; i < l; i++){
+				lang._mixin(dest, arguments[i]);
+			}
+			return dest; // Object
+		},
+
+		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
+		},
+
+		setObject = function(name, value, context){
+			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){
+			return getProp(name.split("."), create, context); // Object
+		},
+
+		exists = function(name, obj){
+			return lang.getObject(name, false, obj) !== undefined; // Boolean
+		},
+
+		opts = Object.prototype.toString,
+
+		// Crockford (ish) functions
+
+		isString = function(it){
+			return (typeof it == "string" || it instanceof String); // Boolean
+		},
+
+		isArray = function(it){
+			return it && (it instanceof Array || typeof it == "array"); // Boolean
+		},
+
+		isFunction = function(it){
+			return opts.call(it) === "[object Function]";
+		},
+
+		isObject = function(it){
+			return it !== undefined &&
+				(it === null || typeof it == "object" || lang.isArray(it) || lang.isFunction(it)); // Boolean
+		},
+
+		isArrayLike = function(it){
+			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){
+			return it && !lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
+		},
+
+		extend = function(constructor, props){
+			for(var i=1, l=arguments.length; i<l; i++){
+				lang._mixin(constructor.prototype, arguments[i]);
+			}
+			return constructor; // Object
+		},
+
+		_hitchArgs = function(scope, method){
+			var pre = _toArray(arguments, 2);
+			var named = lang.isString(method);
+			return function(){
+				// arrayify arguments
+				var args = _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){
+			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(['dojo.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
+			};
+		})(),
+
+		efficient = function(obj, offset, startWith){
+			return (startWith||[]).concat(Array.prototype.slice.call(obj, offset||0));
+		},
+
+		_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,
+
+		partial = function(/*Function|String*/method /*, ...*/){
+			var arr = [ null ];
+			return lang.hitch.apply(dojo, arr.concat(lang._toArray(arguments))); // Function
+		},
+
+		clone = function(/*anything*/ src){
+			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(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, clone);
+		},
+
+
+		trim = String.prototype.trim ?
+			function(str){ return str.trim(); } :
+			function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); },
+
+
+		_pattern = /\{([^\}]+)\}/g,
+
+		replace = function(tmpl, map, pattern){
+			return tmpl.replace(pattern || _pattern, lang.isFunction(map) ?
+				map : function(_, k){ return getObject(k, false, map); });
+		},
+
+		lang = {
+			_extraNames:_extraNames,
+			_mixin:_mixin,
+			mixin:mixin,
+			setObject:setObject,
+			getObject:getObject,
+			exists:exists,
+			isString:isString,
+			isArray:isArray,
+			isFunction:isFunction,
+			isObject:isObject,
+			isArrayLike:isArrayLike,
+			isAlien:isAlien,
+			extend:extend,
+			_hitchArgs:_hitchArgs,
+			hitch:hitch,
+			delegate:delegate,
+			_toArray:_toArray,
+			partial:partial,
+			clone:clone,
+			trim:trim,
+			replace:replace
+		};
+
+	1 && mixin(dojo, lang);
+	return lang;
+
+	/*=====
+	dojo._extraNames
+	// summary:
+	//		Array of strings. Lists property names that must be explicitly processed during for-in interation
+	//		in environments that have has("bug-for-in-skips-shadowed") true.
+	=====*/
+
+	/*=====
+	dojo._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.
+	}
+	=====*/
+
+	/*=====
+	dojo.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:
+	//	| dojo.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);
+	}
+	=====*/
+
+	/*=====
+	dojo.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);
+	}
+	=====*/
+
+	/*=====
+	dojo.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.
+	}
+	=====*/
+
+	/*=====
+	dojo.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
+	}
+	=====*/
+
+	/*=====
+	dojo.isString = function(it){
+	//	summary:
+	//		Return true if it is a String
+	//	it: anything
+	//		Item to test.
+	}
+	=====*/
+
+	/*=====
+	dojo.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.
+	}
+	=====*/
+
+	/*=====
+	dojo.isFunction = function(it){
+	// summary:
+	//		Return true if it is a Function
+	//	it: anything
+	//		Item to test.
+	}
+	=====*/
+
+	/*=====
+	dojo.isObject = function(it){
+	// summary:
+	//		Returns true if it is a JavaScript object (or an Array, a Function
+	//		or null)
+	//	it: anything
+	//		Item to test.
+	}
+	=====*/
+
+	/*=====
+	dojo.isArrayLike = function(it){
+	//	summary:
+	//		similar to dojo.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
+	//		dojo.isArrayLike(), but will return false when passed to
+	//		dojo.isArray().
+	}
+	=====*/
+
+	/*=====
+	dojo.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
+	}
+	=====*/
+
+	/*=====
+	dojo.extend = function(constructor, props){
+	// summary:
+	//		Adds all properties and methods of props to constructor's
+	//		prototype, making them available to all instances created with
+	//		constructor.
+	//	constructor: Object
+	//		Target constructor to extend.
+	//	props: Object...
+	//		One or more objects to mix into constructor.prototype
+	}
+	=====*/
+
+	/*=====
+	dojo.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:
+	//	|	dojo.hitch(foo, "bar")();
+	//		runs foo.bar() in the scope of foo
+	//	example:
+	//	|	dojo.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 = dojo.hitch(foo, "bar", 1, 2);
+	//	|	fn(3); // logs "1, 2, 3"
+	//	example:
+	//	|	var foo = { bar: 2 };
+	//	|	dojo.hitch(foo, function(){ this.bar = 10; })();
+	//		execute an anonymous function in scope of foo
+	}
+	=====*/
+
+	/*=====
+	dojo.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 implementaton 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 = dojo.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
+	}
+	=====*/
+
+	/*=====
+	dojo.partial = function(method){
+	//	summary:
+	//		similar to hitch() except that the scope object is left to be
+	//		whatever the execution context eventually becomes.
+	//	method: Function|String
+	//	description:
+	//		Calling dojo.partial is the functional equivalent of calling:
+	//		|	dojo.hitch(null, funcName, ...);
+	}
+	=====*/
+
+	/*=====
+	dojo.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
+		//		dojo.string.trim()
+	}
+	=====*/
+
+	/*=====
+	dojo.clone = function(src){
+	// summary:
+	//		Clones objects (including DOM nodes) and all children.
+	//		Warning: do not clone cyclic structures.
+	//	src:
+	//		The object to clone
+	}
+	=====*/
+
+	/*=====
+	dojo._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.
+	}
+	=====*/
+
+	/*=====
+	dojo.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:
+		//	|	dojo.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:
+		//	|	dojo.replace("Hello, {0} {2}!",
+		//	|		["Robert", "X", "Cringely"]);
+		//	|	// returns: Hello, Robert Cringely!
+		//	example:
+		//	|	// uses a function for substitutions:
+		//	|	function sum(a){
+		//	|		var t = 0;
+		//	|		dojo.forEach(a, function(x){ t += x; });
+		//	|		return t;
+		//	|	}
+		//	|	dojo.replace(
+		//	|		"{count} payments averaging {avg} USD per payment.",
+		//	|		dojo.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:
+		//	|	dojo.replace("Hello, ${0} ${2}!",
+		//	|		["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g);
+		//	|	// returns: Hello, Robert Cringely!
+		return "";	// String
+	}
+	=====*/
+});
+
diff --git a/lib/dojo/_base/loader.js b/lib/dojo/_base/loader.js
new file mode 100644
index 000000000..fd9b8f3df
--- /dev/null
+++ b/lib/dojo/_base/loader.js
@@ -0,0 +1,8 @@
+/*
+	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
+*/
+
+//>>built
+define("dojo/_base/loader",["./kernel","../has","require","module","./json","./lang","./array"],function(_1,_2,_3,_4,_5,_6,_7){if(!1){console.error("cannot load the Dojo v1.x loader with a foreign loader");return 0;}var _8=function(id){return {src:_4.id,id:id};},_9=function(_a){return _a.replace(/\./g,"/");},_b=/\/\/>>built/,_c=[],_d=[],_e=function(_f,_10,_11){_c.push(_11);_7.forEach(_f.split(","),function(mid){var _12=_13(mid,_10.module);_d.push(_12);_14(_12);});_15();},_16,_17=function(m){_16[m.mid]=1;for(var t,_18,_19=m.deps||[],i=0;i<_19.length;i++){_18=_19[i];if(!(t=_16[_18.mid])){if(t===0||!_17(_18)){_16[m.mid]=0;return false;}}}return true;},_15=function(){var _1a,mid;_16={};for(mid in _1b){_1a=_1b[mid];if(_1a.executed||_1a.noReqPluginCheck){_16[mid]=1;}else{if(_1a.noReqPluginCheck!==0){_1a.noReqPluginCheck=/loadInit\!/.test(mid)||/require\!/.test(mid)?1:0;}if(_1a.noReqPluginCheck){_16[mid]=1;}else{if(_1a.injected!==_1c){_16[mid]=0;}}}}for(var t,i=0,end=_d.length;i<end;i++){_1a=_d[i];if(!(t=_16[_1a.mid])){if(t===0||!_17(_1a)){return;}}}_1d.holdIdle();var _1e=_c;_c=[];_7.forEach(_1e,function(cb){cb(1);});_1d.releaseIdle();},_1f=function(mid,_20,_21){_20([mid],function(_22){_20(_22.names,function(){for(var _23="",_24=[],i=0;i<arguments.length;i++){_23+="var "+_22.names[i]+"= arguments["+i+"]; ";_24.push(arguments[i]);}eval(_23);var _25=_20.module,_26=[],_27={},_28=[],p,_29={provide:function(_2a){_2a=_9(_2a);var _2b=_13(_2a,_25);if(_2b!==_25){_53(_2b);}},require:function(_2c,_2d){_2c=_9(_2c);_2d&&(_13(_2c,_25).result=_4e);_28.push(_2c);},requireLocalization:function(_2e,_2f,_30){_26.length||(_26=["dojo/i18n"]);_30=(_30||_1.locale).toLowerCase();_2e=_9(_2e)+"/nls/"+(/root/i.test(_30)?"":_30+"/")+_9(_2f);if(_13(_2e,_25).isXd){_26.push("dojo/i18n!"+_2e);}},loadInit:function(f){f();}};try{for(p in _29){_27[p]=_1[p];_1[p]=_29[p];}_22.def.apply(null,_24);}catch(e){_54("error",[_8("failedDojoLoadInit"),e]);}finally{for(p in _29){_1[p]=_27[p];}}_28.length&&_26.push("dojo/require!"+_28.join(","));_c.push(_21);_7.forEach(_28,function(mid){var _31=_13(mid,_20.module);_d.push(_31);_14(_31);});_15();});});},_32=function(_33,_34,_35){var _36=/\(|\)/g,_37=1,_38;_36.lastIndex=_34;while((_38=_36.exec(_33))){if(_38[0]==")"){_37-=1;}else{_37+=1;}if(_37==0){break;}}if(_37!=0){throw "unmatched paren around character "+_36.lastIndex+" in: "+_33;}return [_1.trim(_33.substring(_35,_36.lastIndex))+";\n",_36.lastIndex];},_39=/(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg,_3a=/(^|\s)dojo\.(loadInit|require|provide|requireLocalization|requireIf|requireAfterIf|platformRequire)\s*\(/mg,_3b=/(^|\s)(require|define)\s*\(/m,_3c=function(_3d,_3e){var _3f,_40,_41,_42,_43=[],_44=[],_45=[];_3e=_3e||_3d.replace(_39,function(_46){_3a.lastIndex=_3b.lastIndex=0;return (_3a.test(_46)||_3b.test(_46))?"":_46;});while((_3f=_3a.exec(_3e))){_40=_3a.lastIndex;_41=_40-_3f[0].length;_42=_32(_3e,_40,_41);if(_3f[2]=="loadInit"){_43.push(_42[0]);}else{_44.push(_42[0]);}_3a.lastIndex=_42[1];}_45=_43.concat(_44);if(_45.length||!_3b.test(_3e)){return [_3d.replace(/(^|\s)dojo\.loadInit\s*\(/g,"\n0 && dojo.loadInit("),_45.join(""),_45];}else{return 0;}},_47=function(_48,_49){var _4a,id,_4b=[],_4c=[];if(_b.test(_49)||!(_4a=_3c(_49))){return 0;}id=_48.mid+"-*loadInit";for(var p in _13("dojo",_48).result.scopeMap){_4b.push(p);_4c.push("\""+p+"\"");}return "// xdomain rewrite of "+_48.path+"\n"+"define('"+id+"',{\n"+"\tnames:"+_1.toJson(_4b)+",\n"+"\tdef:function("+_4b.join(",")+"){"+_4a[1]+"}"+"});\n\n"+"define("+_1.toJson(_4b.concat(["dojo/loadInit!"+id]))+", function("+_4b.join(",")+"){\n"+_4a[0]+"});";},_1d=_3.initSyncLoader(_e,_15,_47),_4d=_1d.sync,xd=_1d.xd,_1c=_1d.arrived,_4e=_1d.nonmodule,_4f=_1d.executing,_50=_1d.executed,_51=_1d.syncExecStack,_1b=_1d.modules,_52=_1d.execQ,_13=_1d.getModule,_14=_1d.injectModule,_53=_1d.setArrived,_54=_1d.signal,_55=_1d.finishExec,_56=_1d.execModule,_57=_1d.getLegacyMode;_1.provide=function(mid){var _58=_51[0],_59=_6.mixin(_13(_9(mid),_3.module),{executed:_4f,result:_6.getObject(mid,true)});_53(_59);if(_58){(_58.provides||(_58.provides=[])).push(function(){_59.result=_6.getObject(mid);delete _59.provides;_59.executed!==_50&&_55(_59);});}return _59.result;};_2.add("config-publishRequireResult",1,0,0);_1.require=function(_5a,_5b){function _5c(mid,_5d){var _5e=_13(_9(mid),_3.module);if(_51.length&&_51[0].finish){_51[0].finish.push(mid);return undefined;}if(_5e.executed){return _5e.result;}_5d&&(_5e.result=_4e);var _5f=_57();_14(_5e);_5f=_57();if(_5e.executed!==_50&&_5e.injected===_1c){_1d.holdIdle();_56(_5e);_1d.releaseIdle();}if(_5e.executed){return _5e.result;}if(_5f==_4d){if(_5e.cjs){_52.unshift(_5e);}else{_51.length&&(_51[0].finish=[mid]);}}else{_52.push(_5e);}return undefined;};var _60=_5c(_5a,_5b);if(_2("config-publishRequireResult")&&!_6.exists(_5a)&&_60!==undefined){_6.setObject(_5a,_60);}return _60;};_1.loadInit=function(f){f();};_1.registerModulePath=function(_61,_62){var _63={};_63[_61.replace(/\./g,"/")]=_62;_3({paths:_63});};_1.platformRequire=function(_64){var _65=(_64.common||[]).concat(_64[_1._name]||_64["default"]||[]),_66;while(_65.length){if(_6.isArray(_66=_65.shift())){_1.require.apply(_1,_66);}else{_1.require(_66);}}};_1.requireIf=_1.requireAfterIf=function(_67,_68,_69){if(_67){_1.require(_68,_69);}};_1.requireLocalization=function(_6a,_6b,_6c){_3(["../i18n"],function(_6d){_6d.getLocalization(_6a,_6b,_6c);});};return {extractLegacyApiApplications:_3c,require:_1d.dojoRequirePlugin,loadInit:_1f};});
\ No newline at end of file
diff --git a/lib/dojo/_base/loader.js.uncompressed.js b/lib/dojo/_base/loader.js.uncompressed.js
new file mode 100644
index 000000000..0bc2cc5b3
--- /dev/null
+++ b/lib/dojo/_base/loader.js.uncompressed.js
@@ -0,0 +1,718 @@
+define("dojo/_base/loader", ["./kernel", "../has", "require", "module", "./json", "./lang", "./array"], function(dojo, has, require, thisModule, json, lang, array) {
+	// module:
+	//		dojo/_base/lader
+	// summary:
+	//		This module defines the v1.x synchronous loader API.
+
+	// signal the loader in sync mode...
+	//>>pure-amd
+
+	if (!1){
+		console.error("cannot load the Dojo v1.x loader with a foreign loader");
+		return 0;
+	}
+
+	var makeErrorToken = function(id){
+			return {src:thisModule.id, id:id};
+		},
+
+		slashName = function(name){
+			return name.replace(/\./g, "/");
+		},
+
+		buildDetectRe = /\/\/>>built/,
+
+		dojoRequireCallbacks = [],
+		dojoRequireModuleStack = [],
+
+		dojoRequirePlugin = function(mid, require, loaded){
+			dojoRequireCallbacks.push(loaded);
+			array.forEach(mid.split(","), function(mid){
+				var module = getModule(mid, require.module);
+				dojoRequireModuleStack.push(module);
+				injectModule(module);
+			});
+			checkDojoRequirePlugin();
+		},
+
+		// checkDojoRequirePlugin inspects all of the modules demanded by a dojo/require!<module-list> dependency
+		// to see if they have arrived. The loader does not release *any* of these modules to be instantiated
+		// until *all* of these modules are on board, thereby preventing the evaluation of a module with dojo.require's
+		// that reference modules that are not available.
+		//
+		// The algorithm works by traversing the dependency graphs (remember, there can be cycles so they are not trees)
+		// of each module in the dojoRequireModuleStack array (which contains the list of modules demanded by dojo/require!).
+		// The moment a single module is discovered that is missing, the algorithm gives up and indicates that not all
+		// modules are on board. dojo/loadInit! and dojo/require! are ignored because there dependencies are inserted
+		// directly in dojoRequireModuleStack. For example, if "your/module" module depends on "dojo/require!my/module", then
+		// *both* "dojo/require!my/module" and "my/module" will be in dojoRequireModuleStack. Obviously, if "my/module"
+		// is on board, then "dojo/require!my/module" is also satisfied, so the algorithm doesn't check for "dojo/require!my/module".
+		//
+		// Note: inserting a dojo/require!<some-module-list> dependency in the dojoRequireModuleStack achieves nothing
+		// with the current algorithm; however, having such modules present makes it possible to optimize the algorithm
+		//
+		// Note: prior versions of this algorithm had an optimization that signaled loaded on dojo/require! dependencies
+		// individually (rather than waiting for them all to be resolved). The implementation proved problematic with cycles
+		// and plugins. However, it is possible to reattach that strategy in the future.
+
+		// a set from module-id to {undefined | 1 | 0}, where...
+		//   undefined => the module has not been inspected
+		//   0 => the module or at least one of its dependencies has not arrived
+		//   1 => the module is a loadInit! or require! plugin resource, or is currently being traversed (therefore, assume
+		//        OK until proven otherwise), or has been completely traversed and all dependencies have arrived
+		touched,
+
+		traverse = function(m){
+		    touched[m.mid] = 1;
+			for(var t, module, deps = m.deps || [], i= 0; i<deps.length; i++){
+				module = deps[i];
+				if(!(t = touched[module.mid])){
+					if(t===0 || !traverse(module)){
+						touched[m.mid] = 0;
+						return false;
+					}
+				}
+			}
+			return true;
+		},
+
+		checkDojoRequirePlugin = function(){
+			// initialize the touched hash with easy-to-compute values that help short circuit recursive algorithm;
+			// recall loadInit/require plugin modules are dependencies of modules in dojoRequireModuleStack...
+			// which would cause a circular dependency chain that would never be resolved if checked here
+			// notice all dependencies of any particular loadInit/require plugin module will already
+			// be checked since those are pushed into dojoRequireModuleStack explicitly by the
+			// plugin...so if a particular loadInitPlugin module's dependencies are not really
+			// on board, that *will* be detected elsewhere in the traversal.
+			var module, mid;
+			touched = {};
+			for(mid in modules){
+				module = modules[mid];
+				// this could be improved by remembering the result of the regex tests
+				if(module.executed || module.noReqPluginCheck){
+					touched[mid] = 1;
+				}else{
+					if(module.noReqPluginCheck!==0){
+						// tag the module as either a loadInit or require plugin or not for future reference
+						module.noReqPluginCheck = /loadInit\!/.test(mid) || /require\!/.test(mid) ? 1 : 0;
+					}
+					if(module.noReqPluginCheck){
+						touched[mid] = 1;
+					}else if(module.injected!==arrived){
+						// not executed, has not arrived, and is not a loadInit or require plugin resource
+						touched[mid] = 0;
+					}// else, leave undefined and we'll traverse the dependencies
+				}
+			}
+
+			for(var t, i = 0, end = dojoRequireModuleStack.length; i<end; i++){
+				module = dojoRequireModuleStack[i];
+				if(!(t = touched[module.mid])){
+					if(t===0 || !traverse(module)){
+						return;
+					}
+				}
+			}
+			loaderVars.holdIdle();
+			var oldCallbacks = dojoRequireCallbacks;
+			dojoRequireCallbacks = [];
+			array.forEach(oldCallbacks, function(cb){cb(1);});
+			loaderVars.releaseIdle();
+		},
+
+		dojoLoadInitPlugin = function(mid, require, loaded){
+			// mid names a module that defines a "dojo load init" bundle, an object with two properties:
+			//
+			//   * names: a vector of module ids that give top-level names to define in the lexical scope of def
+			//   * def: a function that contains some some legacy loader API applications
+			//
+			// The point of def is to possibly cause some modules to be loaded (but not executed) by dojo/require! where the module
+			// ids are possibly-determined at runtime. For example, here is dojox.gfx from v1.6 expressed as an AMD module using the dojo/loadInit
+			// and dojo/require plugins.
+			//
+			// // dojox/gfx:
+			//
+			//   define("*loadInit_12, {
+			//     names:["dojo", "dijit", "dojox"],
+			//     def: function(){
+			//       dojo.loadInit(function(){
+			//         var gfx = lang.getObject("dojox.gfx", true);
+			//
+			//         //
+			//         // code required to set gfx properties ommitted...
+			//         //
+			//
+			//         // now use the calculations to include the runtime-dependent module
+			//         dojo.require("dojox.gfx." + gfx.renderer);
+			//       });
+			//	   }
+			//   });
+			//
+			//   define(["dojo", "dojo/loadInit!" + id].concat("dojo/require!dojox/gfx/matric,dojox/gfx/_base"), function(dojo){
+			//     // when this AMD factory function is executed, the following modules are guaranteed downloaded but not executed:
+			//     //   "dojox.gfx." + gfx.renderer
+			//     //   dojox.gfx.matrix
+			//     //   dojox.gfx._base
+			//     dojo.provide("dojo.gfx");
+			//     dojo.require("dojox.gfx.matrix");
+			//     dojo.require("dojox.gfx._base");
+			//     dojo.require("dojox.gfx." + gfx.renderer);
+			//     return lang.getObject("dojo.gfx");
+			//   });
+			//  })();
+			//
+			// The idea is to run the legacy loader API with global variables shadowed, which allows these variables to
+			// be relocated. For example, dojox and dojo could be relocated to different names by giving a packageMap and the code above will
+			// execute properly (because the plugin below resolves the load init bundle.names module with respect to the module that demanded
+			// the plugin resource).
+			//
+			// Note that the relocation is specified in the runtime configuration; relocated names need not be set at build-time.
+			//
+			// Warning: this is not the best way to express dojox.gfx as and AMD module. In fact, the module has been properly converted in
+			// v1.7. However, this technique allows the builder to convert legacy modules into AMD modules and guarantee the codepath is the
+			// same in the converted AMD module.
+			require([mid], function(bundle){
+				// notice how names is resolved with respect to the module that demanded the plugin resource
+				require(bundle.names, function(){
+					// bring the bundle names into scope
+					for(var scopeText = "", args= [], i = 0; i<arguments.length; i++){
+						scopeText+= "var " + bundle.names[i] + "= arguments[" + i + "]; ";
+						args.push(arguments[i]);
+					}
+					eval(scopeText);
+
+					var callingModule = require.module,
+						deps = [],
+						hold = {},
+						requireList = [],
+						p,
+						syncLoaderApi = {
+							provide:function(moduleName){
+								// mark modules that arrive consequent to multiple provides in this module as arrived since they can't be injected
+								moduleName = slashName(moduleName);
+								var providedModule = getModule(moduleName, callingModule);
+								if(providedModule!==callingModule){
+									setArrived(providedModule);
+								}
+							},
+							require:function(moduleName, omitModuleCheck){
+								moduleName = slashName(moduleName);
+								omitModuleCheck && (getModule(moduleName, callingModule).result = nonmodule);
+								requireList.push(moduleName);
+							},
+							requireLocalization:function(moduleName, bundleName, locale){
+								// since we're going to need dojo/i8n, add it to deps if not already there
+								deps.length || (deps = ["dojo/i18n"]);
+
+								// figure out if the bundle is xdomain; if so, add it to the depsSet
+								locale = (locale || dojo.locale).toLowerCase();
+								moduleName = slashName(moduleName) + "/nls/" + (/root/i.test(locale) ? "" : locale + "/") + slashName(bundleName);
+								if(getModule(moduleName, callingModule).isXd){
+									deps.push("dojo/i18n!" + moduleName);
+								}// else the bundle will be loaded synchronously when the module is evaluated
+							},
+							loadInit:function(f){
+								f();
+							}
+						};
+
+					// hijack the correct dojo and apply bundle.def
+					try{
+						for(p in syncLoaderApi){
+							hold[p] = dojo[p];
+							dojo[p] = syncLoaderApi[p];
+						}
+						bundle.def.apply(null, args);
+					}catch(e){
+						signal("error", [makeErrorToken("failedDojoLoadInit"), e]);
+					}finally{
+						for(p in syncLoaderApi){
+							dojo[p] = hold[p];
+						}
+					}
+
+					// requireList is the list of modules that need to be downloaded but not executed before the callingModule can be executed
+					requireList.length && deps.push("dojo/require!" + requireList.join(","));
+
+					dojoRequireCallbacks.push(loaded);
+					array.forEach(requireList, function(mid){
+						var module = getModule(mid, require.module);
+						dojoRequireModuleStack.push(module);
+						injectModule(module);
+					});
+					checkDojoRequirePlugin();
+				});
+			});
+		},
+
+		extractApplication = function(
+			text,             // the text to search
+			startSearch,      // the position in text to start looking for the closing paren
+			startApplication  // the position in text where the function application expression starts
+		){
+			// find end of the call by finding the matching end paren
+			// Warning: as usual, this will fail in the presense of unmatched right parans contained in strings, regexs, or unremoved comments
+			var parenRe = /\(|\)/g,
+				matchCount = 1,
+				match;
+			parenRe.lastIndex = startSearch;
+			while((match = parenRe.exec(text))){
+				if(match[0] == ")"){
+					matchCount -= 1;
+				}else{
+					matchCount += 1;
+				}
+				if(matchCount == 0){
+					break;
+				}
+			}
+
+			if(matchCount != 0){
+				throw "unmatched paren around character " + parenRe.lastIndex + " in: " + text;
+			}
+
+			//Put the master matching string in the results.
+			return [dojo.trim(text.substring(startApplication, parenRe.lastIndex))+";\n", parenRe.lastIndex];
+		},
+
+		// the following regex is taken from 1.6. It is a very poor technique to remove comments and
+		// will fail in some cases; for example, consider the code...
+		//
+		//    var message = "Category-1 */* Category-2";
+		//
+		// The regex that follows will see a /* comment and trash the code accordingly. In fact, there are all
+		// kinds of cases like this with strings and regexs that will cause this design to fail miserably.
+		//
+		// Alternative regex designs exist that will result in less-likely failures, but will still fail in many cases.
+		// The only solution guaranteed 100% correct is to parse the code and that seems overkill for this
+		// backcompat/unbuilt-xdomain layer. In the end, since it's been this way for a while, we won't change it.
+		// See the opening paragraphs of Chapter 7 or ECME-262 which describes the lexical abiguity further.
+		removeCommentRe = /(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg,
+
+		syncLoaderApiRe = /(^|\s)dojo\.(loadInit|require|provide|requireLocalization|requireIf|requireAfterIf|platformRequire)\s*\(/mg,
+
+		amdLoaderApiRe = /(^|\s)(require|define)\s*\(/m,
+
+		extractLegacyApiApplications = function(text, noCommentText){
+			// scan the noCommentText for any legacy loader API applications. Copy such applications into result (this is
+			// used by the builder). Move dojo.loadInit applications to loadInitApplications string. Copy all other applications
+			// to otherApplications string. If no applications were found, return 0, signalling an AMD module. Otherwise, return
+			// loadInitApplications + otherApplications. Fixup text by replacing
+			//
+			//   dojo.loadInit(// etc...
+			//
+			// with
+			//
+			//   \n 0 && dojo.loadInit(// etc...
+			//
+			// Which results in the dojo.loadInit from *not* being applied. This design goes a long way towards protecting the
+			// code from an over-agressive removeCommentRe. However...
+			//
+			// WARNING: the removeCommentRe will cause an error if a detected comment removes all or part of a legacy-loader application
+			// that is not in a comment.
+
+			var match, startSearch, startApplication, application,
+				loadInitApplications = [],
+				otherApplications = [],
+				allApplications = [];
+
+			// noCommentText may be provided by a build app with comments extracted by a better method than regex (hopefully)
+			noCommentText = noCommentText || text.replace(removeCommentRe, function(match){
+				// remove iff the detected comment has text that looks like a sync loader API application; this helps by
+				// removing as little as possible, minimizing the changes the janky regex will kill the module
+				syncLoaderApiRe.lastIndex = amdLoaderApiRe.lastIndex = 0;
+				return (syncLoaderApiRe.test(match) || amdLoaderApiRe.test(match)) ? "" : match;
+			});
+
+			// find and extract all dojo.loadInit applications
+			while((match = syncLoaderApiRe.exec(noCommentText))){
+				startSearch = syncLoaderApiRe.lastIndex;
+				startApplication = startSearch  - match[0].length;
+				application = extractApplication(noCommentText, startSearch, startApplication);
+				if(match[2]=="loadInit"){
+					loadInitApplications.push(application[0]);
+				}else{
+					otherApplications.push(application[0]);
+				}
+				syncLoaderApiRe.lastIndex = application[1];
+			}
+			allApplications = loadInitApplications.concat(otherApplications);
+			if(allApplications.length || !amdLoaderApiRe.test(noCommentText)){
+				// either there were some legacy loader API applications or there were no AMD API applications
+				return [text.replace(/(^|\s)dojo\.loadInit\s*\(/g, "\n0 && dojo.loadInit("), allApplications.join(""), allApplications];
+			}else{
+				// legacy loader API *was not* detected and AMD API *was* detected; therefore, assume it's an AMD module
+				return 0;
+			}
+		},
+
+		transformToAmd = function(module, text){
+			// This is roughly the equivalent of dojo._xdCreateResource in 1.6-; however, it expresses a v1.6- dojo
+			// module in terms of AMD define instead of creating the dojo proprietary xdomain module expression.
+			// The module could have originated from several sources:
+			//
+			//   * amd require() a module, e.g., require(["my/module"])
+			//   * amd require() a nonmodule, e.g., require(["my/resource.js"')
+			//   * amd define() deps vector (always a module)
+			//   * dojo.require() a module, e.g. dojo.require("my.module")
+			//   * dojo.require() a nonmodule, e.g., dojo.require("my.module", true)
+			//   * dojo.requireIf/requireAfterIf/platformRequire a module
+			//
+			// The module is scanned for legacy loader API applications; if none are found, then assume the module is an
+			// AMD module and return 0. Otherwise, a synthetic dojo/loadInit plugin resource is created and the module text
+			// is rewritten as an AMD module with the single dependency of this synthetic resource. When the dojo/loadInit
+			// plugin loaded the synthetic resource, it will cause all dojo.loadInit's to be executed, find all dojo.require's
+			// (either directly consequent to dojo.require or indirectly consequent to dojo.require[After]If or
+			// dojo.platformRequire, and finally cause loading of all dojo.required modules with the dojo/require plugin. Thus,
+			// when the dojo/loadInit plugin reports it has been loaded, all modules required by the given module are guaranteed
+			// loaded (but not executed). This then allows the module to execute it's code path without interupts, thereby
+			// following the synchronous code path.
+
+			var extractResult, id, names = [], namesAsStrings = [];
+			if(buildDetectRe.test(text) || !(extractResult = extractLegacyApiApplications(text))){
+				// buildDetectRe.test(text) => a built module, always AMD
+				// extractResult==0 => no sync API
+				return 0;
+			}
+
+			// manufacture a synthetic module id that can never be a real mdule id (just like require does)
+			id = module.mid + "-*loadInit";
+
+			// construct the dojo/loadInit names vector which causes any relocated names to be defined as lexical variables under their not-relocated name
+			// the dojo/loadInit plugin assumes the first name in names is "dojo"
+
+			for(var p in getModule("dojo", module).result.scopeMap){
+				names.push(p);
+				namesAsStrings.push('"' + p + '"');
+			}
+
+			// rewrite the module as a synthetic dojo/loadInit plugin resource + the module expressed as an AMD module that depends on this synthetic resource
+			return "// xdomain rewrite of " + module.path + "\n" +
+				"define('" + id + "',{\n" +
+				"\tnames:" + dojo.toJson(names) + ",\n" +
+				"\tdef:function(" + names.join(",") + "){" + extractResult[1] + "}" +
+				"});\n\n" +
+			    "define(" + dojo.toJson(names.concat(["dojo/loadInit!"+id])) + ", function(" + names.join(",") + "){\n" + extractResult[0] + "});";
+		},
+
+		loaderVars = require.initSyncLoader(dojoRequirePlugin, checkDojoRequirePlugin, transformToAmd),
+
+		sync =
+			loaderVars.sync,
+
+		xd =
+			loaderVars.xd,
+
+		arrived =
+			loaderVars.arrived,
+
+		nonmodule =
+			loaderVars.nonmodule,
+
+		executing =
+			loaderVars.executing,
+
+		executed =
+			loaderVars.executed,
+
+		syncExecStack =
+			loaderVars.syncExecStack,
+
+		modules =
+			loaderVars.modules,
+
+		execQ =
+			loaderVars.execQ,
+
+		getModule =
+			loaderVars.getModule,
+
+		injectModule =
+			loaderVars.injectModule,
+
+		setArrived =
+			loaderVars.setArrived,
+
+		signal =
+			loaderVars.signal,
+
+		finishExec =
+			loaderVars.finishExec,
+
+		execModule =
+			loaderVars.execModule,
+
+		getLegacyMode =
+			loaderVars.getLegacyMode;
+
+	dojo.provide = function(mid){
+		var executingModule = syncExecStack[0],
+			module = lang.mixin(getModule(slashName(mid), require.module), {
+				executed:executing,
+				result:lang.getObject(mid, true)
+			});
+		setArrived(module);
+		if(executingModule){
+			(executingModule.provides || (executingModule.provides = [])).push(function(){
+				module.result = lang.getObject(mid);
+				delete module.provides;
+				module.executed!==executed && finishExec(module);
+			});
+		}// else dojo.provide called not consequent to loading; therefore, give up trying to publish module value to loader namespace
+		return module.result;
+	};
+
+	has.add("config-publishRequireResult", 1, 0, 0);
+
+	dojo.require = function(moduleName, omitModuleCheck) {
+		//	summary:
+		//		loads a Javascript module from the appropriate URI
+		//
+		//	moduleName: String
+		//		module name to load, using periods for separators,
+		//		 e.g. "dojo.date.locale".  Module paths are de-referenced by dojo's
+		//		internal mapping of locations to names and are disambiguated by
+		//		longest prefix. See `dojo.registerModulePath()` for details on
+		//		registering new modules.
+		//
+		//	omitModuleCheck: Boolean?
+		//		if `true`, omitModuleCheck skips the step of ensuring that the
+		//		loaded file actually defines the symbol it is referenced by.
+		//		For example if it called as `dojo.require("a.b.c")` and the
+		//		file located at `a/b/c.js` does not define an object `a.b.c`,
+		//		and exception will be throws whereas no exception is raised
+		//		when called as `dojo.require("a.b.c", true)`
+		//
+		//	description:
+		// 		Modules are loaded via dojo.require by using one of two loaders: the normal loader
+		// 		and the xdomain loader. The xdomain loader is used when dojo was built with a
+		// 		custom build that specified loader=xdomain and the module lives on a modulePath
+		// 		that is a whole URL, with protocol and a domain. The versions of Dojo that are on
+		// 		the Google and AOL CDNs use the xdomain loader.
+		//
+		// 		If the module is loaded via the xdomain loader, it is an asynchronous load, since
+		// 		the module is added via a dynamically created script tag. This
+		// 		means that dojo.require() can return before the module has loaded. However, this
+		// 		should only happen in the case where you do dojo.require calls in the top-level
+		// 		HTML page, or if you purposely avoid the loader checking for dojo.require
+		// 		dependencies in your module by using a syntax like dojo["require"] to load the module.
+		//
+		// 		Sometimes it is useful to not have the loader detect the dojo.require calls in the
+		// 		module so that you can dynamically load the modules as a result of an action on the
+		// 		page, instead of right at module load time.
+		//
+		// 		Also, for script blocks in an HTML page, the loader does not pre-process them, so
+		// 		it does not know to download the modules before the dojo.require calls occur.
+		//
+		// 		So, in those two cases, when you want on-the-fly module loading or for script blocks
+		// 		in the HTML page, special care must be taken if the dojo.required code is loaded
+		// 		asynchronously. To make sure you can execute code that depends on the dojo.required
+		// 		modules, be sure to add the code that depends on the modules in a dojo.addOnLoad()
+		// 		callback. dojo.addOnLoad waits for all outstanding modules to finish loading before
+		// 		executing.
+		//
+		// 		This type of syntax works with both xdomain and normal loaders, so it is good
+		// 		practice to always use this idiom for on-the-fly code loading and in HTML script
+		// 		blocks. If at some point you change loaders and where the code is loaded from,
+		// 		it will all still work.
+		//
+		// 		More on how dojo.require
+		//		`dojo.require("A.B")` first checks to see if symbol A.B is
+		//		defined. If it is, it is simply returned (nothing to do).
+		//
+		//		If it is not defined, it will look for `A/B.js` in the script root
+		//		directory.
+		//
+		//		`dojo.require` throws an exception if it cannot find a file
+		//		to load, or if the symbol `A.B` is not defined after loading.
+		//
+		//		It returns the object `A.B`, but note the caveats above about on-the-fly loading and
+		// 		HTML script blocks when the xdomain loader is loading a module.
+		//
+		//		`dojo.require()` does nothing about importing symbols into
+		//		the current namespace.  It is presumed that the caller will
+		//		take care of that.
+		//
+		// 	example:
+		// 		To use dojo.require in conjunction with dojo.ready:
+		//
+		//		|	dojo.require("foo");
+		//		|	dojo.require("bar");
+		//	   	|	dojo.addOnLoad(function(){
+		//	   	|		//you can now safely do something with foo and bar
+		//	   	|	});
+		//
+		//	example:
+		//		For example, to import all symbols into a local block, you might write:
+		//
+		//		|	with (dojo.require("A.B")) {
+		//		|		...
+		//		|	}
+		//
+		//		And to import just the leaf symbol to a local variable:
+		//
+		//		|	var B = dojo.require("A.B");
+		//	   	|	...
+		//
+		//	returns:
+		//		the required namespace object
+		function doRequire(mid, omitModuleCheck){
+			var module = getModule(slashName(mid), require.module);
+			if(syncExecStack.length && syncExecStack[0].finish){
+				// switched to async loading in the middle of evaluating a legacy module; stop
+				// applying dojo.require so the remaining dojo.requires are applied in order
+				syncExecStack[0].finish.push(mid);
+				return undefined;
+			}
+
+			// recall module.executed has values {0, executing, executed}; therefore, truthy indicates executing or executed
+			if(module.executed){
+				return module.result;
+			}
+			omitModuleCheck && (module.result = nonmodule);
+
+			var currentMode = getLegacyMode();
+
+			// recall, in sync mode to inject is to *eval* the module text
+			// if the module is a legacy module, this is the same as executing
+			// but if the module is an AMD module, this means defining, not executing
+			injectModule(module);
+			// the inject may have changed the mode
+			currentMode = getLegacyMode();
+
+			// in sync mode to dojo.require is to execute
+			if(module.executed!==executed && module.injected===arrived){
+				// the module was already here before injectModule was called probably finishing up a xdomain
+				// load, but maybe a module given to the loader directly rather than having the loader retrieve it
+				loaderVars.holdIdle();
+				execModule(module);
+				loaderVars.releaseIdle();
+			}
+			if(module.executed){
+				return module.result;
+			}
+
+			if(currentMode==sync){
+				// the only way to get here is in sync mode and dojo.required a module that
+				//   * was loaded async in the injectModule application a few lines up
+				//   * was an AMD module that had deps that are being loaded async and therefore couldn't execute
+				if(module.cjs){
+					// the module was an AMD module; unshift, not push, which causes the current traversal to be reattempted from the top
+					execQ.unshift(module);
+				}else{
+					// the module was a legacy module
+					syncExecStack.length && (syncExecStack[0].finish= [mid]);
+				}
+			}else{
+				// the loader wasn't in sync mode on entry; probably async mode; therefore, no expectation of getting
+				// the module value synchronously; make sure it gets executed though
+				execQ.push(module);
+			}
+			return undefined;
+		}
+
+		var result = doRequire(moduleName, omitModuleCheck);
+		if(has("config-publishRequireResult") && !lang.exists(moduleName) && result!==undefined){
+			lang.setObject(moduleName, result);
+		}
+		return result;
+	};
+
+	dojo.loadInit = function(f) {
+		f();
+	};
+
+	dojo.registerModulePath = function(/*String*/moduleName, /*String*/prefix){
+		//	summary:
+		//		Maps a module name to a path
+		//	description:
+		//		An unregistered module is given the default path of ../[module],
+		//		relative to Dojo root. For example, module acme is mapped to
+		//		../acme.  If you want to use a different module name, use
+		//		dojo.registerModulePath.
+		//	example:
+		//		If your dojo.js is located at this location in the web root:
+		//	|	/myapp/js/dojo/dojo/dojo.js
+		//		and your modules are located at:
+		//	|	/myapp/js/foo/bar.js
+		//	|	/myapp/js/foo/baz.js
+		//	|	/myapp/js/foo/thud/xyzzy.js
+		//		Your application can tell Dojo to locate the "foo" namespace by calling:
+		//	|	dojo.registerModulePath("foo", "../../foo");
+		//		At which point you can then use dojo.require() to load the
+		//		modules (assuming they provide() the same things which are
+		//		required). The full code might be:
+		//	|	<script type="text/javascript"
+		//	|		src="/myapp/js/dojo/dojo/dojo.js"></script>
+		//	|	<script type="text/javascript">
+		//	|		dojo.registerModulePath("foo", "../../foo");
+		//	|		dojo.require("foo.bar");
+		//	|		dojo.require("foo.baz");
+		//	|		dojo.require("foo.thud.xyzzy");
+		//	|	</script>
+
+		var paths = {};
+		paths[moduleName.replace(/\./g, "/")] = prefix;
+		require({paths:paths});
+	};
+
+	dojo.platformRequire = function(/*Object*/modMap){
+		//	summary:
+		//		require one or more modules based on which host environment
+		//		Dojo is currently operating in
+		//	description:
+		//		This method takes a "map" of arrays which one can use to
+		//		optionally load dojo modules. The map is indexed by the
+		//		possible dojo.name_ values, with two additional values:
+		//		"default" and "common". The items in the "default" array will
+		//		be loaded if none of the other items have been choosen based on
+		//		dojo.name_, set by your host environment. The items in the
+		//		"common" array will *always* be loaded, regardless of which
+		//		list is chosen.
+		//	example:
+ 		//		|	dojo.platformRequire({
+		//		|		browser: [
+		//		|			"foo.sample", // simple module
+		//		|			"foo.test",
+		//		|			["foo.bar.baz", true] // skip object check in _loadModule (dojo.require)
+		//		|		],
+		//		|		default: [ "foo.sample._base" ],
+		//		|		common: [ "important.module.common" ]
+		//		|	});
+
+		var result = (modMap.common || []).concat(modMap[dojo._name] || modMap["default"] || []),
+			temp;
+		while(result.length){
+			if(lang.isArray(temp = result.shift())){
+				dojo.require.apply(dojo, temp);
+			}else{
+				dojo.require(temp);
+			}
+		}
+	};
+
+	dojo.requireIf = dojo.requireAfterIf = function(/*Boolean*/ condition, /*String*/ moduleName, /*Boolean?*/omitModuleCheck){
+		// summary:
+		//		If the condition is true then call `dojo.require()` for the specified
+		//		resource
+		//
+		// example:
+		//	|	dojo.requireIf(dojo.isBrowser, "my.special.Module");
+
+		if(condition){
+			dojo.require(moduleName, omitModuleCheck);
+		}
+	};
+
+	dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale){
+		require(["../i18n"], function(i18n){
+			i18n.getLocalization(moduleName, bundleName, locale);
+		});
+	};
+
+	return {
+		extractLegacyApiApplications:extractLegacyApiApplications,
+		require:loaderVars.dojoRequirePlugin,
+		loadInit:dojoLoadInitPlugin
+	};
+});
diff --git a/lib/dojo/_base/query-sizzle.js b/lib/dojo/_base/query-sizzle.js
deleted file mode 100644
index aad4e824d..000000000
--- a/lib/dojo/_base/query-sizzle.js
+++ /dev/null
@@ -1,877 +0,0 @@
-/*
-	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._base.query"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.query"] = true;
-/*!
- * Sizzle CSS Selector Engine - v0.9
- *  Copyright 2009, John Resig
- *  Redistributed with the Dojo Toolkit under the terms of the New BSD license.
- *  More information: http://sizzlejs.com/
- *
- *  This version from github, dated 1/23/2009, commit: e374a73bbffc12ec3b5f252e7f76e593c508dfa5
- *  Modified for dojo loader, and to fit into dojo namespace. This was done by passing
- *  dojo object to anonymous function, then assigning Sizzle to dojo.Sizzle instead of window.Sizzle.
- *  Then an alias for dojo.query and dojo._filterQueryResult(). dojo.psuedos is not mapped.
- *  Finally, dojo.provide/require added.
- */
-
-var startDojoMappings= function(dojo) {
-	//Start Dojo mappings.
-	dojo.query = function(/*String*/ query, /*String|DOMNode?*/ root, /*Function?*/listCtor){
-		listCtor = listCtor || dojo.NodeList;
-
-		if(!query){
-			return new listCtor();
-		}
-
-		if(query.constructor == listCtor){
-			return query;
-		}
-		if(!dojo.isString(query)){
-			return new listCtor(query); // dojo.NodeList
-		}
-		if(dojo.isString(root)){
-			root = dojo.byId(root);
-			if(!root){ return new listCtor(); }
-		}
-
-		return dojo.Sizzle(query, root, new listCtor());
-	};
-
-	dojo._filterQueryResult = function(nodeList, simpleFilter){
-		return dojo.Sizzle.filter(simpleFilter, nodeList);
-	};
-};
-
-//Main Sizzle code follows...
-//ns argument, added for dojo, used at the end of the file.
-var defineSizzle= function(ns){
-
-var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|[^[\]]+)+\]|\\.|[^ >+~,(\[]+)+|[>+~])(\s*,\s*)?/g,
-	done = 0,
-	toString = Object.prototype.toString;
-
-var Sizzle = function(selector, context, results, seed) {
-	results = results || [];
-	context = context || document;
-
-	if ( context.nodeType !== 1 && context.nodeType !== 9 )
-		return [];
-	
-	if ( !selector || typeof selector !== "string" ) {
-		return results;
-	}
-
-	var parts = [], m, set, checkSet, check, mode, extra, prune = true;
-	
-	// Reset the position of the chunker regexp (start from head)
-	chunker.lastIndex = 0;
-	
-	while ( (m = chunker.exec(selector)) !== null ) {
-		parts.push( m[1] );
-		
-		if ( m[2] ) {
-			extra = RegExp.rightContext;
-			break;
-		}
-	}
-
-	if ( parts.length > 1 && Expr.match.POS.exec( selector ) ) {
-		if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
-			var later = "", match;
-
-			// Position selectors must be done after the filter
-			while ( (match = Expr.match.POS.exec( selector )) ) {
-				later += match[0];
-				selector = selector.replace( Expr.match.POS, "" );
-			}
-
-			set = Sizzle.filter( later, Sizzle( selector, context ) );
-		} else {
-			set = Expr.relative[ parts[0] ] ?
-				[ context ] :
-				Sizzle( parts.shift(), context );
-
-			while ( parts.length ) {
-				var tmpSet = [];
-
-				selector = parts.shift();
-				if ( Expr.relative[ selector ] )
-					selector += parts.shift();
-
-				for ( var i = 0, l = set.length; i < l; i++ ) {
-					Sizzle( selector, set[i], tmpSet );
-				}
-
-				set = tmpSet;
-			}
-		}
-	} else {
-		var ret = seed ?
-			{ expr: parts.pop(), set: makeArray(seed) } :
-			Sizzle.find( parts.pop(), parts.length === 1 && context.parentNode ? context.parentNode : context );
-		set = Sizzle.filter( ret.expr, ret.set );
-
-		if ( parts.length > 0 ) {
-			checkSet = makeArray(set);
-		} else {
-			prune = false;
-		}
-
-		while ( parts.length ) {
-			var cur = parts.pop(), pop = cur;
-
-			if ( !Expr.relative[ cur ] ) {
-				cur = "";
-			} else {
-				pop = parts.pop();
-			}
-
-			if ( pop == null ) {
-				pop = context;
-			}
-
-			Expr.relative[ cur ]( checkSet, pop );
-		}
-	}
-
-	if ( !checkSet ) {
-		checkSet = set;
-	}
-
-	if ( !checkSet ) {
-		throw "Syntax error, unrecognized expression: " + (cur || selector);
-	}
-
-	if ( toString.call(checkSet) === "[object Array]" ) {
-		if ( !prune ) {
-			results.push.apply( results, checkSet );
-		} else if ( context.nodeType === 1 ) {
-			for ( var i = 0; checkSet[i] != null; i++ ) {
-				if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
-					results.push( set[i] );
-				}
-			}
-		} else {
-			for ( var i = 0; checkSet[i] != null; i++ ) {
-				if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
-					results.push( set[i] );
-				}
-			}
-		}
-	} else {
-		makeArray( checkSet, results );
-	}
-
-	if ( extra ) {
-		Sizzle( extra, context, results, seed );
-	}
-
-	return results;
-};
-
-Sizzle.matches = function(expr, set){
-	return Sizzle(expr, null, null, set);
-};
-
-Sizzle.find = function(expr, context){
-	var set, match;
-
-	if ( !expr ) {
-		return [];
-	}
-
-	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
-		var type = Expr.order[i], match;
-		
-		if ( (match = Expr.match[ type ].exec( expr )) ) {
-			var left = RegExp.leftContext;
-
-			if ( left.substr( left.length - 1 ) !== "\\" ) {
-				match[1] = (match[1] || "").replace(/\\/g, "");
-				set = Expr.find[ type ]( match, context );
-				if ( set != null ) {
-					expr = expr.replace( Expr.match[ type ], "" );
-					break;
-				}
-			}
-		}
-	}
-
-	if ( !set ) {
-		set = context.getElementsByTagName("*");
-	}
-
-	return {set: set, expr: expr};
-};
-
-Sizzle.filter = function(expr, set, inplace, not){
-	var old = expr, result = [], curLoop = set, match, anyFound;
-
-	while ( expr && set.length ) {
-		for ( var type in Expr.filter ) {
-			if ( (match = Expr.match[ type ].exec( expr )) != null ) {
-				var filter = Expr.filter[ type ], goodArray = null, goodPos = 0, found, item;
-				anyFound = false;
-
-				if ( curLoop == result ) {
-					result = [];
-				}
-
-				if ( Expr.preFilter[ type ] ) {
-					match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not );
-
-					if ( !match ) {
-						anyFound = found = true;
-					} else if ( match[0] === true ) {
-						goodArray = [];
-						var last = null, elem;
-						for ( var i = 0; (elem = curLoop[i]) !== undefined; i++ ) {
-							if ( elem && last !== elem ) {
-								goodArray.push( elem );
-								last = elem;
-							}
-						}
-					}
-				}
-
-				if ( match ) {
-					for ( var i = 0; (item = curLoop[i]) !== undefined; i++ ) {
-						if ( item ) {
-							if ( goodArray && item != goodArray[goodPos] ) {
-								goodPos++;
-							}
-	
-							found = filter( item, match, goodPos, goodArray );
-							var pass = not ^ !!found;
-
-							if ( inplace && found != null ) {
-								if ( pass ) {
-									anyFound = true;
-								} else {
-									curLoop[i] = false;
-								}
-							} else if ( pass ) {
-								result.push( item );
-								anyFound = true;
-							}
-						}
-					}
-				}
-
-				if ( found !== undefined ) {
-					if ( !inplace ) {
-						curLoop = result;
-					}
-
-					expr = expr.replace( Expr.match[ type ], "" );
-
-					if ( !anyFound ) {
-						return [];
-					}
-
-					break;
-				}
-			}
-		}
-
-		expr = expr.replace(/\s*,\s*/, "");
-
-		// Improper expression
-		if ( expr == old ) {
-			if ( anyFound == null ) {
-				throw "Syntax error, unrecognized expression: " + expr;
-			} else {
-				break;
-			}
-		}
-
-		old = expr;
-	}
-
-	return curLoop;
-};
-
-var Expr = Sizzle.selectors = {
-	order: [ "ID", "NAME", "TAG" ],
-	match: {
-		ID: /#((?:[\w\u0128-\uFFFF_-]|\\.)+)/,
-		CLASS: /\.((?:[\w\u0128-\uFFFF_-]|\\.)+)/,
-		NAME: /\[name=['"]*((?:[\w\u0128-\uFFFF_-]|\\.)+)['"]*\]/,
-		ATTR: /\[((?:[\w\u0128-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\]/,
-		TAG: /^((?:[\w\u0128-\uFFFF\*_-]|\\.)+)/,
-		CHILD: /:(only|nth|last|first)-child\(?(even|odd|[\dn+-]*)\)?/,
-		POS: /:(nth|eq|gt|lt|first|last|even|odd)\(?(\d*)\)?(?:[^-]|$)/,
-		PSEUDO: /:((?:[\w\u0128-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/
-	},
-	attrMap: {
-		"class": "className",
-		"for": "htmlFor"
-	},
-	relative: {
-		"+": function(checkSet, part){
-			for ( var i = 0, l = checkSet.length; i < l; i++ ) {
-				var elem = checkSet[i];
-				if ( elem ) {
-					var cur = elem.previousSibling;
-					while ( cur && cur.nodeType !== 1 ) {
-						cur = cur.previousSibling;
-					}
-					checkSet[i] = typeof part === "string" ?
-						cur || false :
-						cur === part;
-				}
-			}
-
-			if ( typeof part === "string" ) {
-				Sizzle.filter( part, checkSet, true );
-			}
-		},
-		">": function(checkSet, part){
-			if ( typeof part === "string" && !/\W/.test(part) ) {
-				part = part.toUpperCase();
-
-				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
-					var elem = checkSet[i];
-					if ( elem ) {
-						var parent = elem.parentNode;
-						checkSet[i] = parent.nodeName === part ? parent : false;
-					}
-				}
-			} else {
-				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
-					var elem = checkSet[i];
-					if ( elem ) {
-						checkSet[i] = typeof part === "string" ?
-							elem.parentNode :
-							elem.parentNode === part;
-					}
-				}
-
-				if ( typeof part === "string" ) {
-					Sizzle.filter( part, checkSet, true );
-				}
-			}
-		},
-		"": function(checkSet, part){
-			var doneName = "done" + (done++), checkFn = dirCheck;
-
-			if ( !part.match(/\W/) ) {
-				var nodeCheck = part = part.toUpperCase();
-				checkFn = dirNodeCheck;
-			}
-
-			checkFn("parentNode", part, doneName, checkSet, nodeCheck);
-		},
-		"~": function(checkSet, part){
-			var doneName = "done" + (done++), checkFn = dirCheck;
-
-			if ( typeof part === "string" && !part.match(/\W/) ) {
-				var nodeCheck = part = part.toUpperCase();
-				checkFn = dirNodeCheck;
-			}
-
-			checkFn("previousSibling", part, doneName, checkSet, nodeCheck);
-		}
-	},
-	find: {
-		ID: function(match, context){
-			if ( context.getElementById ) {
-				var m = context.getElementById(match[1]);
-				return m ? [m] : [];
-			}
-		},
-		NAME: function(match, context){
-			return context.getElementsByName ? context.getElementsByName(match[1]) : null;
-		},
-		TAG: function(match, context){
-			return context.getElementsByTagName(match[1]);
-		}
-	},
-	preFilter: {
-		CLASS: function(match, curLoop, inplace, result, not){
-			match = " " + match[1].replace(/\\/g, "") + " ";
-
-			for ( var i = 0; curLoop[i]; i++ ) {
-				if ( not ^ (" " + curLoop[i].className + " ").indexOf(match) >= 0 ) {
-					if ( !inplace )
-						result.push( curLoop[i] );
-				} else if ( inplace ) {
-					curLoop[i] = false;
-				}
-			}
-
-			return false;
-		},
-		ID: function(match){
-			return match[1];
-		},
-		TAG: function(match){
-			return match[1].toUpperCase();
-		},
-		CHILD: function(match){
-			if ( match[1] == "nth" ) {
-				// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
-				var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
-					match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" ||
-					!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
-
-				// calculate the numbers (first)n+(last) including if they are negative
-				match[2] = (test[1] + (test[2] || 1)) - 0;
-				match[3] = test[3] - 0;
-			}
-
-			// TODO: Move to normal caching system
-			match[0] = "done" + (done++);
-
-			return match;
-		},
-		ATTR: function(match){
-			var name = match[1];
-			
-			if ( Expr.attrMap[name] ) {
-				match[1] = Expr.attrMap[name];
-			}
-
-			if ( match[2] === "~=" ) {
-				match[4] = " " + match[4] + " ";
-			}
-
-			return match;
-		},
-		PSEUDO: function(match, curLoop, inplace, result, not){
-			if ( match[1] === "not" ) {
-				// If we're dealing with a complex expression, or a simple one
-				if ( match[3].match(chunker).length > 1 ) {
-					match[3] = Sizzle(match[3], null, null, curLoop);
-				} else {
-					var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
-					if ( !inplace ) {
-						result.push.apply( result, ret );
-					}
-					return false;
-				}
-			}
-			
-			return match;
-		},
-		POS: function(match){
-			match.unshift( true );
-			return match;
-		}
-	},
-	filters: {
-		enabled: function(elem){
-			return elem.disabled === false && elem.type !== "hidden";
-		},
-		disabled: function(elem){
-			return elem.disabled === true;
-		},
-		checked: function(elem){
-			return elem.checked === true;
-		},
-		selected: function(elem){
-			// Accessing this property makes selected-by-default
-			// options in Safari work properly
-			elem.parentNode.selectedIndex;
-			return elem.selected === true;
-		},
-		parent: function(elem){
-			return !!elem.firstChild;
-		},
-		empty: function(elem){
-			return !elem.firstChild;
-		},
-		has: function(elem, i, match){
-			return !!Sizzle( match[3], elem ).length;
-		},
-		header: function(elem){
-			return /h\d/i.test( elem.nodeName );
-		},
-		text: function(elem){
-			return "text" === elem.type;
-		},
-		radio: function(elem){
-			return "radio" === elem.type;
-		},
-		checkbox: function(elem){
-			return "checkbox" === elem.type;
-		},
-		file: function(elem){
-			return "file" === elem.type;
-		},
-		password: function(elem){
-			return "password" === elem.type;
-		},
-		submit: function(elem){
-			return "submit" === elem.type;
-		},
-		image: function(elem){
-			return "image" === elem.type;
-		},
-		reset: function(elem){
-			return "reset" === elem.type;
-		},
-		button: function(elem){
-			return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON";
-		},
-		input: function(elem){
-			return /input|select|textarea|button/i.test(elem.nodeName);
-		}
-	},
-	setFilters: {
-		first: function(elem, i){
-			return i === 0;
-		},
-		last: function(elem, i, match, array){
-			return i === array.length - 1;
-		},
-		even: function(elem, i){
-			return i % 2 === 0;
-		},
-		odd: function(elem, i){
-			return i % 2 === 1;
-		},
-		lt: function(elem, i, match){
-			return i < match[3] - 0;
-		},
-		gt: function(elem, i, match){
-			return i > match[3] - 0;
-		},
-		nth: function(elem, i, match){
-			return match[3] - 0 == i;
-		},
-		eq: function(elem, i, match){
-			return match[3] - 0 == i;
-		}
-	},
-	filter: {
-		CHILD: function(elem, match){
-			var type = match[1], parent = elem.parentNode;
-
-			var doneName = match[0];
-			
-			if ( parent && !parent[ doneName ] ) {
-				var count = 1;
-
-				for ( var node = parent.firstChild; node; node = node.nextSibling ) {
-					if ( node.nodeType == 1 ) {
-						node.nodeIndex = count++;
-					}
-				}
-
-				parent[ doneName ] = count - 1;
-			}
-
-			if ( type == "first" ) {
-				return elem.nodeIndex == 1;
-			} else if ( type == "last" ) {
-				return elem.nodeIndex == parent[ doneName ];
-			} else if ( type == "only" ) {
-				return parent[ doneName ] == 1;
-			} else if ( type == "nth" ) {
-				var add = false, first = match[2], last = match[3];
-
-				if ( first == 1 && last == 0 ) {
-					return true;
-				}
-
-				if ( first == 0 ) {
-					if ( elem.nodeIndex == last ) {
-						add = true;
-					}
-				} else if ( (elem.nodeIndex - last) % first == 0 && (elem.nodeIndex - last) / first >= 0 ) {
-					add = true;
-				}
-
-				return add;
-			}
-		},
-		PSEUDO: function(elem, match, i, array){
-			var name = match[1], filter = Expr.filters[ name ];
-
-			if ( filter ) {
-				return filter( elem, i, match, array );
-			} else if ( name === "contains" ) {
-				return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0;
-			} else if ( name === "not" ) {
-				var not = match[3];
-
-				for ( var i = 0, l = not.length; i < l; i++ ) {
-					if ( not[i] === elem ) {
-						return false;
-					}
-				}
-
-				return true;
-			}
-		},
-		ID: function(elem, match){
-			return elem.nodeType === 1 && elem.getAttribute("id") === match;
-		},
-		TAG: function(elem, match){
-			return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
-		},
-		CLASS: function(elem, match){
-			return match.test( elem.className );
-		},
-		ATTR: function(elem, match){
-			var result = elem[ match[1] ] || elem.getAttribute( match[1] ), value = result + "", type = match[2], check = match[4];
-			return result == null ?
-				false :
-				type === "=" ?
-				value === check :
-				type === "*=" ?
-				value.indexOf(check) >= 0 :
-				type === "~=" ?
-				(" " + value + " ").indexOf(check) >= 0 :
-				!match[4] ?
-				result :
-				type === "!=" ?
-				value != check :
-				type === "^=" ?
-				value.indexOf(check) === 0 :
-				type === "$=" ?
-				value.substr(value.length - check.length) === check :
-				type === "|=" ?
-				value === check || value.substr(0, check.length + 1) === check + "-" :
-				false;
-		},
-		POS: function(elem, match, i, array){
-			var name = match[2], filter = Expr.setFilters[ name ];
-
-			if ( filter ) {
-				return filter( elem, i, match, array );
-			}
-		}
-	}
-};
-
-for ( var type in Expr.match ) {
-	Expr.match[ type ] = RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
-}
-
-var makeArray = function(array, results) {
-	array = Array.prototype.slice.call( array );
-
-	if ( results ) {
-		results.push.apply( results, array );
-		return results;
-	}
-	
-	return array;
-};
-
-// Perform a simple check to determine if the browser is capable of
-// converting a NodeList to an array using builtin methods.
-try {
-	Array.prototype.slice.call( document.documentElement.childNodes );
-
-// Provide a fallback method if it does not work
-} catch(e){
-	makeArray = function(array, results) {
-		var ret = results || [];
-
-		if ( toString.call(array) === "[object Array]" ) {
-			Array.prototype.push.apply( ret, array );
-		} else {
-			if ( typeof array.length === "number" ) {
-				for ( var i = 0, l = array.length; i < l; i++ ) {
-					ret.push( array[i] );
-				}
-			} else {
-				for ( var i = 0; array[i]; i++ ) {
-					ret.push( array[i] );
-				}
-			}
-		}
-
-		return ret;
-	};
-}
-
-// Check to see if the browser returns elements by name when
-// querying by getElementById (and provide a workaround)
-(function(){
-	// We're going to inject a fake input element with a specified name
-	var form = document.createElement("form"),
-		id = "script" + (new Date).getTime();
-	form.innerHTML = "<input name='" + id + "'/>";
-
-	// Inject it into the root element, check its status, and remove it quickly
-	var root = document.documentElement;
-	root.insertBefore( form, root.firstChild );
-
-	// The workaround has to do additional checks after a getElementById
-	// Which slows things down for other browsers (hence the branching)
-	if ( !!document.getElementById( id ) ) {
-		Expr.find.ID = function(match, context){
-			if ( context.getElementById ) {
-				var m = context.getElementById(match[1]);
-				return m ? m.id === match[1] || m.getAttributeNode && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
-			}
-		};
-
-		Expr.filter.ID = function(elem, match){
-			var node = elem.getAttributeNode && elem.getAttributeNode("id");
-			return elem.nodeType === 1 && node && node.nodeValue === match;
-		};
-	}
-
-	root.removeChild( form );
-})();
-
-// Check to see if the browser returns only elements
-// when doing getElementsByTagName("*")
-(function(){
-	// Create a fake element
-	var div = document.createElement("div");
-	div.appendChild( document.createComment("") );
-
-	// Make sure no comments are found
-	if ( div.getElementsByTagName("*").length > 0 ) {
-		Expr.find.TAG = function(match, context){
-			var results = context.getElementsByTagName(match[1]);
-
-			// Filter out possible comments
-			if ( match[1] === "*" ) {
-				var tmp = [];
-
-				for ( var i = 0; results[i]; i++ ) {
-					if ( results[i].nodeType === 1 ) {
-						tmp.push( results[i] );
-					}
-				}
-
-				results = tmp;
-			}
-
-			return results;
-		};
-	}
-})();
-
-if ( document.querySelectorAll ) (function(){
-	var oldSizzle = Sizzle;
-	
-	Sizzle = function(query, context, extra, seed){
-		context = context || document;
-
-		if ( !seed && context.nodeType === 9 ) {
-			try {
-				return makeArray( context.querySelectorAll(query), extra );
-			} catch(e){}
-		}
-		
-		return oldSizzle(query, context, extra, seed);
-	};
-
-	Sizzle.find = oldSizzle.find;
-	Sizzle.filter = oldSizzle.filter;
-	Sizzle.selectors = oldSizzle.selectors;
-	Sizzle.matches = oldSizzle.matches;
-})();
-
-if ( document.documentElement.getElementsByClassName ) {
-	Expr.order.splice(1, 0, "CLASS");
-	Expr.find.CLASS = function(match, context) {
-		return context.getElementsByClassName(match[1]);
-	};
-}
-
-function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck ) {
-	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
-		var elem = checkSet[i];
-		if ( elem ) {
-			elem = elem[dir];
-			var match = false;
-
-			while ( elem && elem.nodeType ) {
-				var done = elem[doneName];
-				if ( done ) {
-					match = checkSet[ done ];
-					break;
-				}
-
-				if ( elem.nodeType === 1 )
-					elem[doneName] = i;
-
-				if ( elem.nodeName === cur ) {
-					match = elem;
-					break;
-				}
-
-				elem = elem[dir];
-			}
-
-			checkSet[i] = match;
-		}
-	}
-}
-
-function dirCheck( dir, cur, doneName, checkSet, nodeCheck ) {
-	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
-		var elem = checkSet[i];
-		if ( elem ) {
-			elem = elem[dir];
-			var match = false;
-
-			while ( elem && elem.nodeType ) {
-				if ( elem[doneName] ) {
-					match = checkSet[ elem[doneName] ];
-					break;
-				}
-
-				if ( elem.nodeType === 1 ) {
-					elem[doneName] = i;
-
-					if ( typeof cur !== "string" ) {
-						if ( elem === cur ) {
-							match = true;
-							break;
-						}
-
-					} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
-						match = elem;
-						break;
-					}
-				}
-
-				elem = elem[dir];
-			}
-
-			checkSet[i] = match;
-		}
-	}
-}
-
-var contains = document.compareDocumentPosition ?  function(a, b){
-	return a.compareDocumentPosition(b) & 16;
-} : function(a, b){
-	return a !== b && (a.contains ? a.contains(b) : true);
-};
-
-// EXPOSE
-
-ns.Sizzle = Sizzle;
-
-};
-
-if (this["dojo"]) {
-  var defined= 0;
-  if (!defined) {
-    // must be in a built version that stripped out the define above
-  	dojo.provide("dojo._base.query");
-    dojo.require("dojo._base.NodeList");
-    defineSizzle(dojo);
-  } // else must be in a source version (or a build that likes define)
-} else {
-  defineSizzle(window);
-}
-
-}
diff --git a/lib/dojo/_base/query.js b/lib/dojo/_base/query.js
index 59411952f..f6ee04bc8 100644
--- a/lib/dojo/_base/query.js
+++ b/lib/dojo/_base/query.js
@@ -4,1598 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.query"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.query"] = true;
-(function(){
-
-/*
-	dojo.query() architectural overview:
-
-		dojo.query is a relatively full-featured CSS3 query library. It is
-		designed to take any valid CSS3 selector and return the nodes matching
-		the selector. To do this quickly, it processes queries in several
-		steps, applying caching where profitable.
-		
-		The steps (roughly in reverse order of the way they appear in the code):
-			1.) check to see if we already have a "query dispatcher"
-				- if so, use that with the given parameterization. Skip to step 4.
-			2.) attempt to determine which branch to dispatch the query to:
-				- JS (optimized DOM iteration)
-				- native (FF3.1+, Safari 3.1+, IE 8+)
-			3.) tokenize and convert to executable "query dispatcher"
-				- this is where the lion's share of the complexity in the
-				  system lies. In the DOM version, the query dispatcher is
-				  assembled as a chain of "yes/no" test functions pertaining to
-				  a section of a simple query statement (".blah:nth-child(odd)"
-				  but not "div div", which is 2 simple statements). Individual
-				  statement dispatchers are cached (to prevent re-definition)
-				  as are entire dispatch chains (to make re-execution of the
-				  same query fast)
-			4.) the resulting query dispatcher is called in the passed scope
-			    (by default the top-level document)
-				- for DOM queries, this results in a recursive, top-down
-				  evaluation of nodes based on each simple query section
-				- for native implementations, this may mean working around spec
-				  bugs. So be it.
-			5.) matched nodes are pruned to ensure they are unique (if necessary)
-*/
-
-var defineQuery= function(d){
-	// define everything in a closure for compressability reasons. "d" is an
-	// alias to "dojo" (or the toolkit alias object, e.g., "acme").
-
-	////////////////////////////////////////////////////////////////////////
-	// Toolkit aliases
-	////////////////////////////////////////////////////////////////////////
-
-	// if you are extracting dojo.query for use in your own system, you will
-	// need to provide these methods and properties. No other porting should be
-	// necessary, save for configuring the system to use a class other than
-	// dojo.NodeList as the return instance instantiator
-	var trim = 			d.trim;
-	var each = 			d.forEach;
-	// 					d.isIE; // float
-	// 					d.isSafari; // float
-	// 					d.isOpera; // float
-	// 					d.isWebKit; // float
-	// 					d.doc ; // document element
-	var qlc = (d._NodeListCtor = 		d.NodeList);
-
-	var getDoc = function(){ return d.doc; };
-	// NOTE(alex): the spec is idiotic. CSS queries should ALWAYS be case-sensitive, but nooooooo
-	var cssCaseBug = ((d.isWebKit||d.isMozilla) && ((getDoc().compatMode) == "BackCompat"));
-
-	////////////////////////////////////////////////////////////////////////
-	// Global utilities
-	////////////////////////////////////////////////////////////////////////
-
-
-	// on browsers that support the "children" collection we can avoid a lot of
-	// iteration on chaff (non-element) nodes.
-	// why.
-	var childNodesName = !!getDoc().firstChild["children"] ? "children" : "childNodes";
-
-	var specials = ">~+";
-
-	// global thunk to determine whether we should treat the current query as
-	// case sensitive or not. This switch is flipped by the query evaluator
-	// based on the document passed as the context to search.
-	var caseSensitive = false;
-
-	// how high?
-	var yesman = function(){ return true; };
-
-	////////////////////////////////////////////////////////////////////////
-	// Tokenizer
-	////////////////////////////////////////////////////////////////////////
-
-	var getQueryParts = function(query){
-		//	summary:
-		//		state machine for query tokenization
-		//	description:
-		//		instead of using a brittle and slow regex-based CSS parser,
-		//		dojo.query implements an AST-style query representation. This
-		//		representation is only generated once per query. For example,
-		//		the same query run multiple times or under different root nodes
-		//		does not re-parse the selector expression but instead uses the
-		//		cached data structure. The state machine implemented here
-		//		terminates on the last " " (space) character and returns an
-		//		ordered array of query component structures (or "parts"). Each
-		//		part represents an operator or a simple CSS filtering
-		//		expression. The structure for parts is documented in the code
-		//		below.
-
-
-		// NOTE:
-		//		this code is designed to run fast and compress well. Sacrifices
-		//		to readability and maintainability have been made.  Your best
-		//		bet when hacking the tokenizer is to put The Donnas on *really*
-		//		loud (may we recommend their "Spend The Night" release?) and
-		//		just assume you're gonna make mistakes. Keep the unit tests
-		//		open and run them frequently. Knowing is half the battle ;-)
-		if(specials.indexOf(query.slice(-1)) >= 0){
-			// if we end with a ">", "+", or "~", that means we're implicitly
-			// searching all children, so make it explicit
-			query += " * "
-		}else{
-			// if you have not provided a terminator, one will be provided for
-			// you...
-			query += " ";
-		}
-
-		var ts = function(/*Integer*/ s, /*Integer*/ e){
-			// trim and slice.
-
-			// take an index to start a string slice from and an end position
-			// and return a trimmed copy of that sub-string
-			return trim(query.slice(s, e));
-		}
-
-		// the overall data graph of the full query, as represented by queryPart objects
-		var queryParts = [];
-
-
-		// state keeping vars
-		var inBrackets = -1, inParens = -1, inMatchFor = -1,
-			inPseudo = -1, inClass = -1, inId = -1, inTag = -1,
-			lc = "", cc = "", pStart;
-
-		// iteration vars
-		var x = 0, // index in the query
-			ql = query.length,
-			currentPart = null, // data structure representing the entire clause
-			_cp = null; // the current pseudo or attr matcher
-
-		// several temporary variables are assigned to this structure during a
-		// potential sub-expression match:
-		//		attr:
-		//			a string representing the current full attribute match in a
-		//			bracket expression
-		//		type:
-		//			if there's an operator in a bracket expression, this is
-		//			used to keep track of it
-		//		value:
-		//			the internals of parenthetical expression for a pseudo. for
-		//			:nth-child(2n+1), value might be "2n+1"
-
-		var endTag = function(){
-			// called when the tokenizer hits the end of a particular tag name.
-			// Re-sets state variables for tag matching and sets up the matcher
-			// to handle the next type of token (tag or operator).
-			if(inTag >= 0){
-				var tv = (inTag == x) ? null : ts(inTag, x); // .toLowerCase();
-				currentPart[ (specials.indexOf(tv) < 0) ? "tag" : "oper" ] = tv;
-				inTag = -1;
-			}
-		}
-
-		var endId = function(){
-			// called when the tokenizer might be at the end of an ID portion of a match
-			if(inId >= 0){
-				currentPart.id = ts(inId, x).replace(/\\/g, "");
-				inId = -1;
-			}
-		}
-
-		var endClass = function(){
-			// called when the tokenizer might be at the end of a class name
-			// match. CSS allows for multiple classes, so we augment the
-			// current item with another class in its list
-			if(inClass >= 0){
-				currentPart.classes.push(ts(inClass+1, x).replace(/\\/g, ""));
-				inClass = -1;
-			}
-		}
-
-		var endAll = function(){
-			// at the end of a simple fragment, so wall off the matches
-			endId(); endTag(); endClass();
-		}
-
-		var endPart = function(){
-			endAll();
-			if(inPseudo >= 0){
-				currentPart.pseudos.push({ name: ts(inPseudo+1, x) });
-			}
-			// hint to the selector engine to tell it whether or not it
-			// needs to do any iteration. Many simple selectors don't, and
-			// we can avoid significant construction-time work by advising
-			// the system to skip them
-			currentPart.loops = (
-					currentPart.pseudos.length ||
-					currentPart.attrs.length ||
-					currentPart.classes.length	);
-
-			currentPart.oquery = currentPart.query = ts(pStart, x); // save the full expression as a string
-
-
-			// otag/tag are hints to suggest to the system whether or not
-			// it's an operator or a tag. We save a copy of otag since the
-			// tag name is cast to upper-case in regular HTML matches. The
-			// system has a global switch to figure out if the current
-			// expression needs to be case sensitive or not and it will use
-			// otag or tag accordingly
-			currentPart.otag = currentPart.tag = (currentPart["oper"]) ? null : (currentPart.tag || "*");
-
-			if(currentPart.tag){
-				// if we're in a case-insensitive HTML doc, we likely want
-				// the toUpperCase when matching on element.tagName. If we
-				// do it here, we can skip the string op per node
-				// comparison
-				currentPart.tag = currentPart.tag.toUpperCase();
-			}
-
-			// add the part to the list
-			if(queryParts.length && (queryParts[queryParts.length-1].oper)){
-				// operators are always infix, so we remove them from the
-				// list and attach them to the next match. The evaluator is
-				// responsible for sorting out how to handle them.
-				currentPart.infixOper = queryParts.pop();
-				currentPart.query = currentPart.infixOper.query + " " + currentPart.query;
-				/*
-				console.debug(	"swapping out the infix",
-								currentPart.infixOper,
-								"and attaching it to",
-								currentPart);
-				*/
-			}
-			queryParts.push(currentPart);
-
-			currentPart = null;
-		}
-
-		// iterate over the query, character by character, building up a
-		// list of query part objects
-		for(; lc=cc, cc=query.charAt(x), x < ql; x++){
-			//		cc: the current character in the match
-			//		lc: the last character (if any)
-
-			// someone is trying to escape something, so don't try to match any
-			// fragments. We assume we're inside a literal.
-			if(lc == "\\"){ continue; }
-			if(!currentPart){ // a part was just ended or none has yet been created
-				// NOTE: I hate all this alloc, but it's shorter than writing tons of if's
-				pStart = x;
-				//	rules describe full CSS sub-expressions, like:
-				//		#someId
-				//		.className:first-child
-				//	but not:
-				//		thinger > div.howdy[type=thinger]
-				//	the indidual components of the previous query would be
-				//	split into 3 parts that would be represented a structure
-				//	like:
-				//		[
-				//			{
-				//				query: "thinger",
-				//				tag: "thinger",
-				//			},
-				//			{
-				//				query: "div.howdy[type=thinger]",
-				//				classes: ["howdy"],
-				//				infixOper: {
-				//					query: ">",
-				//					oper: ">",
-				//				}
-				//			},
-				//		]
-				currentPart = {
-					query: null, // the full text of the part's rule
-					pseudos: [], // CSS supports multiple pseud-class matches in a single rule
-					attrs: [], 	// CSS supports multi-attribute match, so we need an array
-					classes: [], // class matches may be additive, e.g.: .thinger.blah.howdy
-					tag: null, 	// only one tag...
-					oper: null, // ...or operator per component. Note that these wind up being exclusive.
-					id: null, 	// the id component of a rule
-					getTag: function(){
-						return (caseSensitive) ? this.otag : this.tag;
-					}
-				};
-
-				// if we don't have a part, we assume we're going to start at
-				// the beginning of a match, which should be a tag name. This
-				// might fault a little later on, but we detect that and this
-				// iteration will still be fine.
-				inTag = x;
-			}
-
-			if(inBrackets >= 0){
-				// look for a the close first
-				if(cc == "]"){ // if we're in a [...] clause and we end, do assignment
-					if(!_cp.attr){
-						// no attribute match was previously begun, so we
-						// assume this is an attribute existence match in the
-						// form of [someAttributeName]
-						_cp.attr = ts(inBrackets+1, x);
-					}else{
-						// we had an attribute already, so we know that we're
-						// matching some sort of value, as in [attrName=howdy]
-						_cp.matchFor = ts((inMatchFor||inBrackets+1), x);
-					}
-					var cmf = _cp.matchFor;
-					if(cmf){
-						// try to strip quotes from the matchFor value. We want
-						// [attrName=howdy] to match the same
-						//	as [attrName = 'howdy' ]
-						if(	(cmf.charAt(0) == '"') || (cmf.charAt(0)  == "'") ){
-							_cp.matchFor = cmf.slice(1, -1);
-						}
-					}
-					// end the attribute by adding it to the list of attributes.
-					currentPart.attrs.push(_cp);
-					_cp = null; // necessary?
-					inBrackets = inMatchFor = -1;
-				}else if(cc == "="){
-					// if the last char was an operator prefix, make sure we
-					// record it along with the "=" operator.
-					var addToCc = ("|~^$*".indexOf(lc) >=0 ) ? lc : "";
-					_cp.type = addToCc+cc;
-					_cp.attr = ts(inBrackets+1, x-addToCc.length);
-					inMatchFor = x+1;
-				}
-				// now look for other clause parts
-			}else if(inParens >= 0){
-				// if we're in a parenthetical expression, we need to figure
-				// out if it's attached to a pseudo-selector rule like
-				// :nth-child(1)
-				if(cc == ")"){
-					if(inPseudo >= 0){
-						_cp.value = ts(inParens+1, x);
-					}
-					inPseudo = inParens = -1;
-				}
-			}else if(cc == "#"){
-				// start of an ID match
-				endAll();
-				inId = x+1;
-			}else if(cc == "."){
-				// start of a class match
-				endAll();
-				inClass = x;
-			}else if(cc == ":"){
-				// start of a pseudo-selector match
-				endAll();
-				inPseudo = x;
-			}else if(cc == "["){
-				// start of an attribute match.
-				endAll();
-				inBrackets = x;
-				// provide a new structure for the attribute match to fill-in
-				_cp = {
-					/*=====
-					attr: null, type: null, matchFor: null
-					=====*/
-				};
-			}else if(cc == "("){
-				// we really only care if we've entered a parenthetical
-				// expression if we're already inside a pseudo-selector match
-				if(inPseudo >= 0){
-					// provide a new structure for the pseudo match to fill-in
-					_cp = {
-						name: ts(inPseudo+1, x),
-						value: null
-					}
-					currentPart.pseudos.push(_cp);
-				}
-				inParens = x;
-			}else if(
-				(cc == " ") &&
-				// if it's a space char and the last char is too, consume the
-				// current one without doing more work
-				(lc != cc)
-			){
-				endPart();
-			}
-		}
-		return queryParts;
-	};
-	
-
-	////////////////////////////////////////////////////////////////////////
-	// DOM query infrastructure
-	////////////////////////////////////////////////////////////////////////
-
-	var agree = function(first, second){
-		// the basic building block of the yes/no chaining system. agree(f1,
-		// f2) generates a new function which returns the boolean results of
-		// both of the passed functions to a single logical-anded result. If
-		// either are not passed, the other is used exclusively.
-		if(!first){ return second; }
-		if(!second){ return first; }
-
-		return function(){
-			return first.apply(window, arguments) && second.apply(window, arguments);
-		}
-	};
-
-	var getArr = function(i, arr){
-		// helps us avoid array alloc when we don't need it
-		var r = arr||[]; // FIXME: should this be 'new d._NodeListCtor()' ?
-		if(i){ r.push(i); }
-		return r;
-	};
-
-	var _isElement = function(n){ return (1 == n.nodeType); };
-
-	// FIXME: need to coalesce _getAttr with defaultGetter
-	var blank = "";
-	var _getAttr = function(elem, attr){
-		if(!elem){ return blank; }
-		if(attr == "class"){
-			return elem.className || blank;
-		}
-		if(attr == "for"){
-			return elem.htmlFor || blank;
-		}
-		if(attr == "style"){
-			return elem.style.cssText || blank;
-		}
-		return (caseSensitive ? elem.getAttribute(attr) : elem.getAttribute(attr, 2)) || blank;
-	};
-
-	var attrs = {
-		"*=": function(attr, value){
-			return function(elem){
-				// E[foo*="bar"]
-				//		an E element whose "foo" attribute value contains
-				//		the substring "bar"
-				return (_getAttr(elem, attr).indexOf(value)>=0);
-			}
-		},
-		"^=": function(attr, value){
-			// E[foo^="bar"]
-			//		an E element whose "foo" attribute value begins exactly
-			//		with the string "bar"
-			return function(elem){
-				return (_getAttr(elem, attr).indexOf(value)==0);
-			}
-		},
-		"$=": function(attr, value){
-			// E[foo$="bar"]
-			//		an E element whose "foo" attribute value ends exactly
-			//		with the string "bar"
-			var tval = " "+value;
-			return function(elem){
-				var ea = " "+_getAttr(elem, attr);
-				return (ea.lastIndexOf(value)==(ea.length-value.length));
-			}
-		},
-		"~=": function(attr, value){
-			// E[foo~="bar"]
-			//		an E element whose "foo" attribute value is a list of
-			//		space-separated values, one of which is exactly equal
-			//		to "bar"
-
-			// return "[contains(concat(' ',@"+attr+",' '), ' "+ value +" ')]";
-			var tval = " "+value+" ";
-			return function(elem){
-				var ea = " "+_getAttr(elem, attr)+" ";
-				return (ea.indexOf(tval)>=0);
-			}
-		},
-		"|=": function(attr, value){
-			// E[hreflang|="en"]
-			//		an E element whose "hreflang" attribute has a
-			//		hyphen-separated list of values beginning (from the
-			//		left) with "en"
-			var valueDash = " "+value+"-";
-			return function(elem){
-				var ea = " "+_getAttr(elem, attr);
-				return (
-					(ea == value) ||
-					(ea.indexOf(valueDash)==0)
-				);
-			}
-		},
-		"=": function(attr, value){
-			return function(elem){
-				return (_getAttr(elem, attr) == value);
-			}
-		}
-	};
-
-	// avoid testing for node type if we can. Defining this in the negative
-	// here to avoid negation in the fast path.
-	var _noNES = (typeof getDoc().firstChild.nextElementSibling == "undefined");
-	var _ns = !_noNES ? "nextElementSibling" : "nextSibling";
-	var _ps = !_noNES ? "previousElementSibling" : "previousSibling";
-	var _simpleNodeTest = (_noNES ? _isElement : yesman);
-
-	var _lookLeft = function(node){
-		// look left
-		while(node = node[_ps]){
-			if(_simpleNodeTest(node)){ return false; }
-		}
-		return true;
-	};
-
-	var _lookRight = function(node){
-		// look right
-		while(node = node[_ns]){
-			if(_simpleNodeTest(node)){ return false; }
-		}
-		return true;
-	};
-
-	var getNodeIndex = function(node){
-		var root = node.parentNode;
-		var i = 0,
-			tret = root[childNodesName],
-			ci = (node["_i"]||-1),
-			cl = (root["_l"]||-1);
-
-		if(!tret){ return -1; }
-		var l = tret.length;
-
-		// we calculate the parent length as a cheap way to invalidate the
-		// cache. It's not 100% accurate, but it's much more honest than what
-		// other libraries do
-		if( cl == l && ci >= 0 && cl >= 0 ){
-			// if it's legit, tag and release
-			return ci;
-		}
-
-		// else re-key things
-		root["_l"] = l;
-		ci = -1;
-		for(var te = root["firstElementChild"]||root["firstChild"]; te; te = te[_ns]){
-			if(_simpleNodeTest(te)){
-				te["_i"] = ++i;
-				if(node === te){
-					// NOTE:
-					// 	shortcutting the return at this step in indexing works
-					// 	very well for benchmarking but we avoid it here since
-					// 	it leads to potential O(n^2) behavior in sequential
-					// 	getNodexIndex operations on a previously un-indexed
-					// 	parent. We may revisit this at a later time, but for
-					// 	now we just want to get the right answer more often
-					// 	than not.
-					ci = i;
-				}
-			}
-		}
-		return ci;
-	};
-
-	var isEven = function(elem){
-		return !((getNodeIndex(elem)) % 2);
-	};
-
-	var isOdd = function(elem){
-		return ((getNodeIndex(elem)) % 2);
-	};
-
-	var pseudos = {
-		"checked": function(name, condition){
-			return function(elem){
-				return !!("checked" in elem ? elem.checked : elem.selected);
-			}
-		},
-		"first-child": function(){ return _lookLeft; },
-		"last-child": function(){ return _lookRight; },
-		"only-child": function(name, condition){
-			return function(node){
-				if(!_lookLeft(node)){ return false; }
-				if(!_lookRight(node)){ return false; }
-				return true;
-			};
-		},
-		"empty": function(name, condition){
-			return function(elem){
-				// DomQuery and jQuery get this wrong, oddly enough.
-				// The CSS 3 selectors spec is pretty explicit about it, too.
-				var cn = elem.childNodes;
-				var cnl = elem.childNodes.length;
-				// if(!cnl){ return true; }
-				for(var x=cnl-1; x >= 0; x--){
-					var nt = cn[x].nodeType;
-					if((nt === 1)||(nt == 3)){ return false; }
-				}
-				return true;
-			}
-		},
-		"contains": function(name, condition){
-			var cz = condition.charAt(0);
-			if( cz == '"' || cz == "'" ){ //remove quote
-				condition = condition.slice(1, -1);
-			}
-			return function(elem){
-				return (elem.innerHTML.indexOf(condition) >= 0);
-			}
-		},
-		"not": function(name, condition){
-			var p = getQueryParts(condition)[0];
-			var ignores = { el: 1 };
-			if(p.tag != "*"){
-				ignores.tag = 1;
-			}
-			if(!p.classes.length){
-				ignores.classes = 1;
-			}
-			var ntf = getSimpleFilterFunc(p, ignores);
-			return function(elem){
-				return (!ntf(elem));
-			}
-		},
-		"nth-child": function(name, condition){
-			var pi = parseInt;
-			// avoid re-defining function objects if we can
-			if(condition == "odd"){
-				return isOdd;
-			}else if(condition == "even"){
-				return isEven;
-			}
-			// FIXME: can we shorten this?
-			if(condition.indexOf("n") != -1){
-				var tparts = condition.split("n", 2);
-				var pred = tparts[0] ? ((tparts[0] == '-') ? -1 : pi(tparts[0])) : 1;
-				var idx = tparts[1] ? pi(tparts[1]) : 0;
-				var lb = 0, ub = -1;
-				if(pred > 0){
-					if(idx < 0){
-						idx = (idx % pred) && (pred + (idx % pred));
-					}else if(idx>0){
-						if(idx >= pred){
-							lb = idx - idx % pred;
-						}
-						idx = idx % pred;
-					}
-				}else if(pred<0){
-					pred *= -1;
-					// idx has to be greater than 0 when pred is negative;
-					// shall we throw an error here?
-					if(idx > 0){
-						ub = idx;
-						idx = idx % pred;
-					}
-				}
-				if(pred > 0){
-					return function(elem){
-						var i = getNodeIndex(elem);
-						return (i>=lb) && (ub<0 || i<=ub) && ((i % pred) == idx);
-					}
-				}else{
-					condition = idx;
-				}
-			}
-			var ncount = pi(condition);
-			return function(elem){
-				return (getNodeIndex(elem) == ncount);
-			}
-		}
-	};
-
-	var defaultGetter = (d.isIE < 9 || (dojo.isIE && dojo.isQuirks)) ? function(cond){
-		var clc = cond.toLowerCase();
-		if(clc == "class"){ cond = "className"; }
-		return function(elem){
-			return (caseSensitive ? elem.getAttribute(cond) : elem[cond]||elem[clc]);
-		}
-	} : function(cond){
-		return function(elem){
-			return (elem && elem.getAttribute && elem.hasAttribute(cond));
-		}
-	};
-
-	var getSimpleFilterFunc = function(query, ignores){
-		// generates a node tester function based on the passed query part. The
-		// query part is one of the structures generated by the query parser
-		// when it creates the query AST. The "ignores" object specifies which
-		// (if any) tests to skip, allowing the system to avoid duplicating
-		// work where it may have already been taken into account by other
-		// factors such as how the nodes to test were fetched in the first
-		// place
-		if(!query){ return yesman; }
-		ignores = ignores||{};
-
-		var ff = null;
-
-		if(!("el" in ignores)){
-			ff = agree(ff, _isElement);
-		}
-
-		if(!("tag" in ignores)){
-			if(query.tag != "*"){
-				ff = agree(ff, function(elem){
-					return (elem && (elem.tagName == query.getTag()));
-				});
-			}
-		}
-
-		if(!("classes" in ignores)){
-			each(query.classes, function(cname, idx, arr){
-				// get the class name
-				/*
-				var isWildcard = cname.charAt(cname.length-1) == "*";
-				if(isWildcard){
-					cname = cname.substr(0, cname.length-1);
-				}
-				// I dislike the regex thing, even if memoized in a cache, but it's VERY short
-				var re = new RegExp("(?:^|\\s)" + cname + (isWildcard ? ".*" : "") + "(?:\\s|$)");
-				*/
-				var re = new RegExp("(?:^|\\s)" + cname + "(?:\\s|$)");
-				ff = agree(ff, function(elem){
-					return re.test(elem.className);
-				});
-				ff.count = idx;
-			});
-		}
-
-		if(!("pseudos" in ignores)){
-			each(query.pseudos, function(pseudo){
-				var pn = pseudo.name;
-				if(pseudos[pn]){
-					ff = agree(ff, pseudos[pn](pn, pseudo.value));
-				}
-			});
-		}
-
-		if(!("attrs" in ignores)){
-			each(query.attrs, function(attr){
-				var matcher;
-				var a = attr.attr;
-				// type, attr, matchFor
-				if(attr.type && attrs[attr.type]){
-					matcher = attrs[attr.type](a, attr.matchFor);
-				}else if(a.length){
-					matcher = defaultGetter(a);
-				}
-				if(matcher){
-					ff = agree(ff, matcher);
-				}
-			});
-		}
-
-		if(!("id" in ignores)){
-			if(query.id){
-				ff = agree(ff, function(elem){
-					return (!!elem && (elem.id == query.id));
-				});
-			}
-		}
-
-		if(!ff){
-			if(!("default" in ignores)){
-				ff = yesman;
-			}
-		}
-		return ff;
-	};
-
-	var _nextSibling = function(filterFunc){
-		return function(node, ret, bag){
-			while(node = node[_ns]){
-				if(_noNES && (!_isElement(node))){ continue; }
-				if(
-					(!bag || _isUnique(node, bag)) &&
-					filterFunc(node)
-				){
-					ret.push(node);
-				}
-				break;
-			}
-			return ret;
-		}
-	};
-
-	var _nextSiblings = function(filterFunc){
-		return function(root, ret, bag){
-			var te = root[_ns];
-			while(te){
-				if(_simpleNodeTest(te)){
-					if(bag && !_isUnique(te, bag)){
-						break;
-					}
-					if(filterFunc(te)){
-						ret.push(te);
-					}
-				}
-				te = te[_ns];
-			}
-			return ret;
-		}
-	};
-
-	// get an array of child *elements*, skipping text and comment nodes
-	var _childElements = function(filterFunc){
-		filterFunc = filterFunc||yesman;
-		return function(root, ret, bag){
-			// get an array of child elements, skipping text and comment nodes
-			var te, x = 0, tret = root[childNodesName];
-			while(te = tret[x++]){
-				if(
-					_simpleNodeTest(te) &&
-					(!bag || _isUnique(te, bag)) &&
-					(filterFunc(te, x))
-				){
-					ret.push(te);
-				}
-			}
-			return ret;
-		};
-	};
-	
-	/*
-	// thanks, Dean!
-	var itemIsAfterRoot = d.isIE ? function(item, root){
-		return (item.sourceIndex > root.sourceIndex);
-	} : function(item, root){
-		return (item.compareDocumentPosition(root) == 2);
-	};
-	*/
-
-	// test to see if node is below root
-	var _isDescendant = function(node, root){
-		var pn = node.parentNode;
-		while(pn){
-			if(pn == root){
-				break;
-			}
-			pn = pn.parentNode;
-		}
-		return !!pn;
-	};
-
-	var _getElementsFuncCache = {};
-
-	var getElementsFunc = function(query){
-		var retFunc = _getElementsFuncCache[query.query];
-		// if we've got a cached dispatcher, just use that
-		if(retFunc){ return retFunc; }
-		// else, generate a new on
-
-		// NOTE:
-		//		this function returns a function that searches for nodes and
-		//		filters them.  The search may be specialized by infix operators
-		//		(">", "~", or "+") else it will default to searching all
-		//		descendants (the " " selector). Once a group of children is
-		//		found, a test function is applied to weed out the ones we
-		//		don't want. Many common cases can be fast-pathed. We spend a
-		//		lot of cycles to create a dispatcher that doesn't do more work
-		//		than necessary at any point since, unlike this function, the
-		//		dispatchers will be called every time. The logic of generating
-		//		efficient dispatchers looks like this in pseudo code:
-		//
-		//		# if it's a purely descendant query (no ">", "+", or "~" modifiers)
-		//		if infixOperator == " ":
-		//			if only(id):
-		//				return def(root):
-		//					return d.byId(id, root);
-		//
-		//			elif id:
-		//				return def(root):
-		//					return filter(d.byId(id, root));
-		//
-		//			elif cssClass && getElementsByClassName:
-		//				return def(root):
-		//					return filter(root.getElementsByClassName(cssClass));
-		//
-		//			elif only(tag):
-		//				return def(root):
-		//					return root.getElementsByTagName(tagName);
-		//
-		//			else:
-		//				# search by tag name, then filter
-		//				return def(root):
-		//					return filter(root.getElementsByTagName(tagName||"*"));
-		//
-		//		elif infixOperator == ">":
-		//			# search direct children
-		//			return def(root):
-		//				return filter(root.children);
-		//
-		//		elif infixOperator == "+":
-		//			# search next sibling
-		//			return def(root):
-		//				return filter(root.nextElementSibling);
-		//
-		//		elif infixOperator == "~":
-		//			# search rightward siblings
-		//			return def(root):
-		//				return filter(nextSiblings(root));
-
-		var io = query.infixOper;
-		var oper = (io ? io.oper : "");
-		// the default filter func which tests for all conditions in the query
-		// part. This is potentially inefficient, so some optimized paths may
-		// re-define it to test fewer things.
-		var filterFunc = getSimpleFilterFunc(query, { el: 1 });
-		var qt = query.tag;
-		var wildcardTag = ("*" == qt);
-		var ecs = getDoc()["getElementsByClassName"];
-
-		if(!oper){
-			// if there's no infix operator, then it's a descendant query. ID
-			// and "elements by class name" variants can be accelerated so we
-			// call them out explicitly:
-			if(query.id){
-				// testing shows that the overhead of yesman() is acceptable
-				// and can save us some bytes vs. re-defining the function
-				// everywhere.
-				filterFunc = (!query.loops && wildcardTag) ?
-					yesman :
-					getSimpleFilterFunc(query, { el: 1, id: 1 });
-
-				retFunc = function(root, arr){
-					var te = d.byId(query.id, (root.ownerDocument||root));
-					if(!te || !filterFunc(te)){ return; }
-					if(9 == root.nodeType){ // if root's a doc, we just return directly
-						return getArr(te, arr);
-					}else{ // otherwise check ancestry
-						if(_isDescendant(te, root)){
-							return getArr(te, arr);
-						}
-					}
-				}
-			}else if(
-				ecs &&
-				// isAlien check. Workaround for Prototype.js being totally evil/dumb.
-				/\{\s*\[native code\]\s*\}/.test(String(ecs)) &&
-				query.classes.length &&
-				!cssCaseBug
-			){
-				// it's a class-based query and we've got a fast way to run it.
-
-				// ignore class and ID filters since we will have handled both
-				filterFunc = getSimpleFilterFunc(query, { el: 1, classes: 1, id: 1 });
-				var classesString = query.classes.join(" ");
-				retFunc = function(root, arr, bag){
-					var ret = getArr(0, arr), te, x=0;
-					var tret = root.getElementsByClassName(classesString);
-					while((te = tret[x++])){
-						if(filterFunc(te, root) && _isUnique(te, bag)){
-							ret.push(te);
-						}
-					}
-					return ret;
-				};
-
-			}else if(!wildcardTag && !query.loops){
-				// it's tag only. Fast-path it.
-				retFunc = function(root, arr, bag){
-					var ret = getArr(0, arr), te, x=0;
-					var tret = root.getElementsByTagName(query.getTag());
-					while((te = tret[x++])){
-						if(_isUnique(te, bag)){
-							ret.push(te);
-						}
-					}
-					return ret;
-				};
-			}else{
-				// the common case:
-				//		a descendant selector without a fast path. By now it's got
-				//		to have a tag selector, even if it's just "*" so we query
-				//		by that and filter
-				filterFunc = getSimpleFilterFunc(query, { el: 1, tag: 1, id: 1 });
-				retFunc = function(root, arr, bag){
-					var ret = getArr(0, arr), te, x=0;
-					// we use getTag() to avoid case sensitivity issues
-					var tret = root.getElementsByTagName(query.getTag());
-					while((te = tret[x++])){
-						if(filterFunc(te, root) && _isUnique(te, bag)){
-							ret.push(te);
-						}
-					}
-					return ret;
-				};
-			}
-		}else{
-			// the query is scoped in some way. Instead of querying by tag we
-			// use some other collection to find candidate nodes
-			var skipFilters = { el: 1 };
-			if(wildcardTag){
-				skipFilters.tag = 1;
-			}
-			filterFunc = getSimpleFilterFunc(query, skipFilters);
-			if("+" == oper){
-				retFunc = _nextSibling(filterFunc);
-			}else if("~" == oper){
-				retFunc = _nextSiblings(filterFunc);
-			}else if(">" == oper){
-				retFunc = _childElements(filterFunc);
-			}
-		}
-		// cache it and return
-		return _getElementsFuncCache[query.query] = retFunc;
-	};
-
-	var filterDown = function(root, queryParts){
-		// NOTE:
-		//		this is the guts of the DOM query system. It takes a list of
-		//		parsed query parts and a root and finds children which match
-		//		the selector represented by the parts
-		var candidates = getArr(root), qp, x, te, qpl = queryParts.length, bag, ret;
-
-		for(var i = 0; i < qpl; i++){
-			ret = [];
-			qp = queryParts[i];
-			x = candidates.length - 1;
-			if(x > 0){
-				// if we have more than one root at this level, provide a new
-				// hash to use for checking group membership but tell the
-				// system not to post-filter us since we will already have been
-				// gauranteed to be unique
-				bag = {};
-				ret.nozip = true;
-			}
-			var gef = getElementsFunc(qp);
-			for(var j = 0; (te = candidates[j]); j++){
-				// for every root, get the elements that match the descendant
-				// selector, adding them to the "ret" array and filtering them
-				// via membership in this level's bag. If there are more query
-				// parts, then this level's return will be used as the next
-				// level's candidates
-				gef(te, ret, bag);
-			}
-			if(!ret.length){ break; }
-			candidates = ret;
-		}
-		return ret;
-	};
-
-	////////////////////////////////////////////////////////////////////////
-	// the query runner
-	////////////////////////////////////////////////////////////////////////
-
-	// these are the primary caches for full-query results. The query
-	// dispatcher functions are generated then stored here for hash lookup in
-	// the future
-	var _queryFuncCacheDOM = {},
-		_queryFuncCacheQSA = {};
-
-	// this is the second level of spliting, from full-length queries (e.g.,
-	// "div.foo .bar") into simple query expressions (e.g., ["div.foo",
-	// ".bar"])
-	var getStepQueryFunc = function(query){
-		var qparts = getQueryParts(trim(query));
-
-		// if it's trivial, avoid iteration and zipping costs
-		if(qparts.length == 1){
-			// we optimize this case here to prevent dispatch further down the
-			// chain, potentially slowing things down. We could more elegantly
-			// handle this in filterDown(), but it's slower for simple things
-			// that need to be fast (e.g., "#someId").
-			var tef = getElementsFunc(qparts[0]);
-			return function(root){
-				var r = tef(root, new qlc());
-				if(r){ r.nozip = true; }
-				return r;
-			}
-		}
-
-		// otherwise, break it up and return a runner that iterates over the parts recursively
-		return function(root){
-			return filterDown(root, qparts);
-		}
-	};
-
-	// NOTES:
-	//	* we can't trust QSA for anything but document-rooted queries, so
-	//	  caching is split into DOM query evaluators and QSA query evaluators
-	//	* caching query results is dirty and leak-prone (or, at a minimum,
-	//	  prone to unbounded growth). Other toolkits may go this route, but
-	//	  they totally destroy their own ability to manage their memory
-	//	  footprint. If we implement it, it should only ever be with a fixed
-	//	  total element reference # limit and an LRU-style algorithm since JS
-	//	  has no weakref support. Caching compiled query evaluators is also
-	//	  potentially problematic, but even on large documents the size of the
-	//	  query evaluators is often < 100 function objects per evaluator (and
-	//	  LRU can be applied if it's ever shown to be an issue).
-	//	* since IE's QSA support is currently only for HTML documents and even
-	//	  then only in IE 8's "standards mode", we have to detect our dispatch
-	//	  route at query time and keep 2 separate caches. Ugg.
-
-	// we need to determine if we think we can run a given query via
-	// querySelectorAll or if we'll need to fall back on DOM queries to get
-	// there. We need a lot of information about the environment and the query
-	// to make the determiniation (e.g. does it support QSA, does the query in
-	// question work in the native QSA impl, etc.).
-	var nua = navigator.userAgent;
-	// some versions of Safari provided QSA, but it was buggy and crash-prone.
-	// We need te detect the right "internal" webkit version to make this work.
-	var wk = "WebKit/";
-	var is525 = (
-		d.isWebKit &&
-		(nua.indexOf(wk) > 0) &&
-		(parseFloat(nua.split(wk)[1]) > 528)
-	);
-
-	// IE QSA queries may incorrectly include comment nodes, so we throw the
-	// zipping function into "remove" comments mode instead of the normal "skip
-	// it" which every other QSA-clued browser enjoys
-	var noZip = d.isIE ? "commentStrip" : "nozip";
-
-	var qsa = "querySelectorAll";
-	var qsaAvail = (
-		!!getDoc()[qsa] &&
-		// see #5832
-		(!d.isSafari || (d.isSafari > 3.1) || is525 )
-	);
-
-	//Don't bother with n+3 type of matches, IE complains if we modify those.
-	var infixSpaceRe = /n\+\d|([^ ])?([>~+])([^ =])?/g;
-	var infixSpaceFunc = function(match, pre, ch, post) {
-		return ch ? (pre ? pre + " " : "") + ch + (post ? " " + post : "") : /*n+3*/ match;
-	};
-
-	var getQueryFunc = function(query, forceDOM){
-		//Normalize query. The CSS3 selectors spec allows for omitting spaces around
-		//infix operators, >, ~ and +
-		//Do the work here since detection for spaces is used as a simple "not use QSA"
-		//test below.
-		query = query.replace(infixSpaceRe, infixSpaceFunc);
-
-		if(qsaAvail){
-			// if we've got a cached variant and we think we can do it, run it!
-			var qsaCached = _queryFuncCacheQSA[query];
-			if(qsaCached && !forceDOM){ return qsaCached; }
-		}
-
-		// else if we've got a DOM cached variant, assume that we already know
-		// all we need to and use it
-		var domCached = _queryFuncCacheDOM[query];
-		if(domCached){ return domCached; }
-
-		// TODO:
-		//		today we're caching DOM and QSA branches separately so we
-		//		recalc useQSA every time. If we had a way to tag root+query
-		//		efficiently, we'd be in good shape to do a global cache.
-
-		var qcz = query.charAt(0);
-		var nospace = (-1 == query.indexOf(" "));
-
-		// byId searches are wicked fast compared to QSA, even when filtering
-		// is required
-		if( (query.indexOf("#") >= 0) && (nospace) ){
-			forceDOM = true;
-		}
-
-		var useQSA = (
-			qsaAvail && (!forceDOM) &&
-			// as per CSS 3, we can't currently start w/ combinator:
-			//		http://www.w3.org/TR/css3-selectors/#w3cselgrammar
-			(specials.indexOf(qcz) == -1) &&
-			// IE's QSA impl sucks on pseudos
-			(!d.isIE || (query.indexOf(":") == -1)) &&
-
-			(!(cssCaseBug && (query.indexOf(".") >= 0))) &&
-
-			// FIXME:
-			//		need to tighten up browser rules on ":contains" and "|=" to
-			//		figure out which aren't good
-			//		Latest webkit (around 531.21.8) does not seem to do well with :checked on option
-			//		elements, even though according to spec, selected options should
-			//		match :checked. So go nonQSA for it:
-			//		http://bugs.dojotoolkit.org/ticket/5179
-			(query.indexOf(":contains") == -1) && (query.indexOf(":checked") == -1) &&
-			(query.indexOf("|=") == -1) // some browsers don't grok it
-		);
-
-		// TODO:
-		//		if we've got a descendant query (e.g., "> .thinger" instead of
-		//		just ".thinger") in a QSA-able doc, but are passed a child as a
-		//		root, it should be possible to give the item a synthetic ID and
-		//		trivially rewrite the query to the form "#synid > .thinger" to
-		//		use the QSA branch
-
-
-		if(useQSA){
-			var tq = (specials.indexOf(query.charAt(query.length-1)) >= 0) ?
-						(query + " *") : query;
-			return _queryFuncCacheQSA[query] = function(root){
-				try{
-					// the QSA system contains an egregious spec bug which
-					// limits us, effectively, to only running QSA queries over
-					// entire documents.  See:
-					//		http://ejohn.org/blog/thoughts-on-queryselectorall/
-					//	despite this, we can also handle QSA runs on simple
-					//	selectors, but we don't want detection to be expensive
-					//	so we're just checking for the presence of a space char
-					//	right now. Not elegant, but it's cheaper than running
-					//	the query parser when we might not need to
-					if(!((9 == root.nodeType) || nospace)){ throw ""; }
-					var r = root[qsa](tq);
-					// skip expensive duplication checks and just wrap in a NodeList
-					r[noZip] = true;
-					return r;
-				}catch(e){
-					// else run the DOM branch on this query, ensuring that we
-					// default that way in the future
-					return getQueryFunc(query, true)(root);
-				}
-			}
-		}else{
-			// DOM branch
-			var parts = query.split(/\s*,\s*/);
-			return _queryFuncCacheDOM[query] = ((parts.length < 2) ?
-				// if not a compound query (e.g., ".foo, .bar"), cache and return a dispatcher
-				getStepQueryFunc(query) :
-				// if it *is* a complex query, break it up into its
-				// constituent parts and return a dispatcher that will
-				// merge the parts when run
-				function(root){
-					var pindex = 0, // avoid array alloc for every invocation
-						ret = [],
-						tp;
-					while((tp = parts[pindex++])){
-						ret = ret.concat(getStepQueryFunc(tp)(root));
-					}
-					return ret;
-				}
-			);
-		}
-	};
-
-	var _zipIdx = 0;
-
-	// NOTE:
-	//		this function is Moo inspired, but our own impl to deal correctly
-	//		with XML in IE
-	var _nodeUID = d.isIE ? function(node){
-		if(caseSensitive){
-			// XML docs don't have uniqueID on their nodes
-			return (node.getAttribute("_uid") || node.setAttribute("_uid", ++_zipIdx) || _zipIdx);
-
-		}else{
-			return node.uniqueID;
-		}
-	} :
-	function(node){
-		return (node._uid || (node._uid = ++_zipIdx));
-	};
-
-	// determine if a node in is unique in a "bag". In this case we don't want
-	// to flatten a list of unique items, but rather just tell if the item in
-	// question is already in the bag. Normally we'd just use hash lookup to do
-	// this for us but IE's DOM is busted so we can't really count on that. On
-	// the upside, it gives us a built in unique ID function.
-	var _isUnique = function(node, bag){
-		if(!bag){ return 1; }
-		var id = _nodeUID(node);
-		if(!bag[id]){ return bag[id] = 1; }
-		return 0;
-	};
-
-	// attempt to efficiently determine if an item in a list is a dupe,
-	// returning a list of "uniques", hopefully in doucment order
-	var _zipIdxName = "_zipIdx";
-	var _zip = function(arr){
-		if(arr && arr.nozip){
-			return (qlc._wrap) ? qlc._wrap(arr) : arr;
-		}
-		// var ret = new d._NodeListCtor();
-		var ret = new qlc();
-		if(!arr || !arr.length){ return ret; }
-		if(arr[0]){
-			ret.push(arr[0]);
-		}
-		if(arr.length < 2){ return ret; }
-
-		_zipIdx++;
-		
-		// we have to fork here for IE and XML docs because we can't set
-		// expandos on their nodes (apparently). *sigh*
-		if(d.isIE && caseSensitive){
-			var szidx = _zipIdx+"";
-			arr[0].setAttribute(_zipIdxName, szidx);
-			for(var x = 1, te; te = arr[x]; x++){
-				if(arr[x].getAttribute(_zipIdxName) != szidx){
-					ret.push(te);
-				}
-				te.setAttribute(_zipIdxName, szidx);
-			}
-		}else if(d.isIE && arr.commentStrip){
-			try{
-				for(var x = 1, te; te = arr[x]; x++){
-					if(_isElement(te)){
-						ret.push(te);
-					}
-				}
-			}catch(e){ /* squelch */ }
-		}else{
-			if(arr[0]){ arr[0][_zipIdxName] = _zipIdx; }
-			for(var x = 1, te; te = arr[x]; x++){
-				if(arr[x][_zipIdxName] != _zipIdx){
-					ret.push(te);
-				}
-				te[_zipIdxName] = _zipIdx;
-			}
-		}
-		return ret;
-	};
-
-	// the main executor
-	d.query = function(/*String*/ query, /*String|DOMNode?*/ root){
-		//	summary:
-		//		Returns nodes which match the given CSS3 selector, searching the
-		//		entire document by default but optionally taking a node to scope
-		//		the search by. Returns an instance of dojo.NodeList.
-		//	description:
-		//		dojo.query() is the swiss army knife of DOM node manipulation in
-		//		Dojo. Much like Prototype's "$$" (bling-bling) function or JQuery's
-		//		"$" function, dojo.query provides robust, high-performance
-		//		CSS-based node selector support with the option of scoping searches
-		//		to a particular sub-tree of a document.
-		//
-		//		Supported Selectors:
-		//		--------------------
-		//
-		//		dojo.query() supports a rich set of CSS3 selectors, including:
-		//
-		//			* class selectors (e.g., `.foo`)
-		//			* node type selectors like `span`
-		//			* ` ` descendant selectors
-		//			* `>` child element selectors
-		//			* `#foo` style ID selectors
-		//			* `*` universal selector
-		//			* `~`, the preceded-by sibling selector
-		//			* `+`, the immediately preceded-by sibling selector
-		//			* attribute queries:
-		//			|	* `[foo]` attribute presence selector
-		//			|	* `[foo='bar']` attribute value exact match
-		//			|	* `[foo~='bar']` attribute value list item match
-		//			|	* `[foo^='bar']` attribute start match
-		//			|	* `[foo$='bar']` attribute end match
-		//			|	* `[foo*='bar']` attribute substring match
-		//			* `:first-child`, `:last-child`, and `:only-child` positional selectors
-		//			* `:empty` content emtpy selector
-		//			* `:checked` pseudo selector
-		//			* `:nth-child(n)`, `:nth-child(2n+1)` style positional calculations
-		//			* `:nth-child(even)`, `:nth-child(odd)` positional selectors
-		//			* `:not(...)` negation pseudo selectors
-		//
-		//		Any legal combination of these selectors will work with
-		//		`dojo.query()`, including compound selectors ("," delimited).
-		//		Very complex and useful searches can be constructed with this
-		//		palette of selectors and when combined with functions for
-		//		manipulation presented by dojo.NodeList, many types of DOM
-		//		manipulation operations become very straightforward.
-		//
-		//		Unsupported Selectors:
-		//		----------------------
-		//
-		//		While dojo.query handles many CSS3 selectors, some fall outside of
-		//		what's reasonable for a programmatic node querying engine to
-		//		handle. Currently unsupported selectors include:
-		//
-		//			* namespace-differentiated selectors of any form
-		//			* all `::` pseduo-element selectors
-		//			* certain pseduo-selectors which don't get a lot of day-to-day use:
-		//			|	* `:root`, `:lang()`, `:target`, `:focus`
-		//			* all visual and state selectors:
-		//			|	* `:root`, `:active`, `:hover`, `:visisted`, `:link`,
-		//				  `:enabled`, `:disabled`
-		//			* `:*-of-type` pseudo selectors
-		//
-		//		dojo.query and XML Documents:
-		//		-----------------------------
-		//
-		//		`dojo.query` (as of dojo 1.2) supports searching XML documents
-		//		in a case-sensitive manner. If an HTML document is served with
-		//		a doctype that forces case-sensitivity (e.g., XHTML 1.1
-		//		Strict), dojo.query() will detect this and "do the right
-		//		thing". Case sensitivity is dependent upon the document being
-		//		searched and not the query used. It is therefore possible to
-		//		use case-sensitive queries on strict sub-documents (iframes,
-		//		etc.) or XML documents while still assuming case-insensitivity
-		//		for a host/root document.
-		//
-		//		Non-selector Queries:
-		//		---------------------
-		//
-		//		If something other than a String is passed for the query,
-		//		`dojo.query` will return a new `dojo.NodeList` instance
-		//		constructed from that parameter alone and all further
-		//		processing will stop. This means that if you have a reference
-		//		to a node or NodeList, you can quickly construct a new NodeList
-		//		from the original by calling `dojo.query(node)` or
-		//		`dojo.query(list)`.
-		//
-		//	query:
-		//		The CSS3 expression to match against. For details on the syntax of
-		//		CSS3 selectors, see <http://www.w3.org/TR/css3-selectors/#selectors>
-		//	root:
-		//		A DOMNode (or node id) to scope the search from. Optional.
-		//	returns: dojo.NodeList
-		//		An instance of `dojo.NodeList`. Many methods are available on
-		//		NodeLists for searching, iterating, manipulating, and handling
-		//		events on the matched nodes in the returned list.
-		//	example:
-		//		search the entire document for elements with the class "foo":
-		//	|	dojo.query(".foo");
-		//		these elements will match:
-		//	|	<span class="foo"></span>
-		//	|	<span class="foo bar"></span>
-		//	|	<p class="thud foo"></p>
-		//	example:
-		//		search the entire document for elements with the classes "foo" *and* "bar":
-		//	|	dojo.query(".foo.bar");
-		//		these elements will match:
-		//	|	<span class="foo bar"></span>
-		//		while these will not:
-		//	|	<span class="foo"></span>
-		//	|	<p class="thud foo"></p>
-		//	example:
-		//		find `<span>` elements which are descendants of paragraphs and
-		//		which have a "highlighted" class:
-		//	|	dojo.query("p span.highlighted");
-		//		the innermost span in this fragment matches:
-		//	|	<p class="foo">
-		//	|		<span>...
-		//	|			<span class="highlighted foo bar">...</span>
-		//	|		</span>
-		//	|	</p>
-		//	example:
-		//		set an "odd" class on all odd table rows inside of the table
-		//		`#tabular_data`, using the `>` (direct child) selector to avoid
-		//		affecting any nested tables:
-		//	|	dojo.query("#tabular_data > tbody > tr:nth-child(odd)").addClass("odd");
-		//	example:
-		//		remove all elements with the class "error" from the document
-		//		and store them in a list:
-		//	|	var errors = dojo.query(".error").orphan();
-		//	example:
-		//		add an onclick handler to every submit button in the document
-		//		which causes the form to be sent via Ajax instead:
-		//	|	dojo.query("input[type='submit']").onclick(function(e){
-		//	|		dojo.stopEvent(e); // prevent sending the form
-		//	|		var btn = e.target;
-		//	|		dojo.xhrPost({
-		//	|			form: btn.form,
-		//	|			load: function(data){
-		//	|				// replace the form with the response
-		//	|				var div = dojo.doc.createElement("div");
-		//	|				dojo.place(div, btn.form, "after");
-		//	|				div.innerHTML = data;
-		//	|				dojo.style(btn.form, "display", "none");
-		//	|			}
-		//	|		});
-		//	|	});
-
-		//Set list constructor to desired value. This can change
-		//between calls, so always re-assign here.
-		qlc = d._NodeListCtor;
-
-		if(!query){
-			return new qlc();
-		}
-
-		if(query.constructor == qlc){
-			return query;
-		}
-		if(typeof query != "string"){ // inline'd type check
-			return new qlc(query); // dojo.NodeList
-		}
-		if(typeof root == "string"){ // inline'd type check
-			root = d.byId(root);
-			if(!root){ return new qlc(); }
-		}
-
-		root = root||getDoc();
-		var od = root.ownerDocument||root.documentElement;
-
-		// throw the big case sensitivity switch
-
-		// NOTE:
-		// 		Opera in XHTML mode doesn't detect case-sensitivity correctly
-		// 		and it's not clear that there's any way to test for it
-		caseSensitive = (root.contentType && root.contentType=="application/xml") ||
-						(d.isOpera && (root.doctype || od.toString() == "[object XMLDocument]")) ||
-						(!!od) &&
-						(d.isIE ? od.xml : (root.xmlVersion||od.xmlVersion));
-
-		// NOTE:
-		//		adding "true" as the 2nd argument to getQueryFunc is useful for
-		//		testing the DOM branch without worrying about the
-		//		behavior/performance of the QSA branch.
-		var r = getQueryFunc(query)(root);
-
-		// FIXME:
-		//		need to investigate this branch WRT #8074 and #8075
-		if(r && r.nozip && !qlc._wrap){
-			return r;
-		}
-		return _zip(r); // dojo.NodeList
-	}
-
-	// FIXME: need to add infrastructure for post-filtering pseudos, ala :last
-	d.query.pseudos = pseudos;
-
-	// function for filtering a NodeList based on a selector, optimized for simple selectors
-	d._filterQueryResult = function(/*NodeList*/ nodeList, /*String*/ filter, /*String|DOMNode?*/ root){
-		var tmpNodeList = new d._NodeListCtor(),
-			parts = getQueryParts(filter),
-			filterFunc =
-				(parts.length == 1 && !/[^\w#\.]/.test(filter)) ?
-				getSimpleFilterFunc(parts[0]) :
-				function(node) {
-					return dojo.query(filter, root).indexOf(node) != -1;
-				};
-		for(var x = 0, te; te = nodeList[x]; x++){
-			if(filterFunc(te)){ tmpNodeList.push(te); }
-		}
-		return tmpNodeList;
-	}
-};//end defineQuery
-
-var defineAcme= function(){
-	// a self-sufficient query impl
-	acme = {
-		trim: function(/*String*/ str){
-			// summary:
-			//		trims whitespaces from both sides of the string
-			str = str.replace(/^\s+/, '');
-			for(var i = str.length - 1; i >= 0; i--){
-				if(/\S/.test(str.charAt(i))){
-					str = str.substring(0, i + 1);
-					break;
-				}
-			}
-			return str;	// String
-		},
-		forEach: function(/*String*/ arr, /*Function*/ callback, /*Object?*/ thisObject){
-			//	summary:
-			// 		an iterator function that passes items, indexes,
-			// 		and the array to a callback
-			if(!arr || !arr.length){ return; }
-			for(var i=0,l=arr.length; i<l; ++i){
-				callback.call(thisObject||window, arr[i], i, arr);
-			}
-		},
-		byId: function(id, doc){
-			// 	summary:
-			//		a function that return an element by ID, but also
-			//		accepts nodes safely
-			if(typeof id == "string"){
-				return (doc||document).getElementById(id); // DomNode
-			}else{
-				return id; // DomNode
-			}
-		},
-		// the default document to search
-		doc: document,
-		// the constructor for node list objects returned from query()
-		NodeList: Array
-	};
-
-	// define acme.isIE, acme.isSafari, acme.isOpera, etc.
-	var n = navigator;
-	var dua = n.userAgent;
-	var dav = n.appVersion;
-	var tv = parseFloat(dav);
-	acme.isOpera = (dua.indexOf("Opera") >= 0) ? tv: undefined;
-	acme.isKhtml = (dav.indexOf("Konqueror") >= 0) ? tv : undefined;
-	acme.isWebKit = parseFloat(dua.split("WebKit/")[1]) || undefined;
-	acme.isChrome = parseFloat(dua.split("Chrome/")[1]) || undefined;
-	var index = Math.max(dav.indexOf("WebKit"), dav.indexOf("Safari"), 0);
-	if(index && !acme.isChrome){
-		acme.isSafari = parseFloat(dav.split("Version/")[1]);
-		if(!acme.isSafari || parseFloat(dav.substr(index + 7)) <= 419.3){
-			acme.isSafari = 2;
-		}
-	}
-	if(document.all && !acme.isOpera){
-		acme.isIE = parseFloat(dav.split("MSIE ")[1]) || undefined;
-	}
-
-	Array._wrap = function(arr){ return arr; };
-  return acme;
-};
-
-	//prefers queryPortability, then acme, then dojo
-	if(this["dojo"]){
-		dojo.provide("dojo._base.query");
-		dojo.require("dojo._base.NodeList");
-		dojo.require("dojo._base.lang");
-		defineQuery(this["queryPortability"]||this["acme"]||dojo);
-	}else{
-		defineQuery(this["queryPortability"]||this["acme"]||defineAcme());
-	}
-
-})();
-
-/*
-*/
-
-}
+//>>built
+define("dojo/_base/query",["./kernel","../query","./NodeList"],function(_1){return _1.query;});
\ No newline at end of file
diff --git a/lib/dojo/_base/query.js.uncompressed.js b/lib/dojo/_base/query.js.uncompressed.js
new file mode 100644
index 000000000..a1b161b0b
--- /dev/null
+++ b/lib/dojo/_base/query.js.uncompressed.js
@@ -0,0 +1,3 @@
+define("dojo/_base/query", ["./kernel", "../query", "./NodeList"], function(dojo){
+	return dojo.query;
+});
diff --git a/lib/dojo/_base/sniff.js b/lib/dojo/_base/sniff.js
new file mode 100644
index 000000000..5849b99e9
--- /dev/null
+++ b/lib/dojo/_base/sniff.js
@@ -0,0 +1,8 @@
+/*
+	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
+*/
+
+//>>built
+define("dojo/_base/sniff",["./kernel","../has"],function(_1,_2){if(!1){return _2;}_1.isBrowser=true,_1._name="browser";var _3=_2.add,n=navigator,_4=n.userAgent,_5=n.appVersion,tv=parseFloat(_5),_6,_7,_8,_9,_a,_b,_c,_d,_e,_f,_10,_11,_12,_13,_14;if(_4.indexOf("AdobeAIR")>=0){_7=1;}_8=(_5.indexOf("Konqueror")>=0)?tv:0;_9=parseFloat(_4.split("WebKit/")[1])||undefined;_a=parseFloat(_4.split("Chrome/")[1])||undefined;_b=_5.indexOf("Macintosh")>=0;_12=/iPhone|iPod|iPad/.test(_4);_13=parseFloat(_4.split("Android ")[1])||undefined;_14=typeof opera!="undefined"&&opera.wiiremote;var _15=Math.max(_5.indexOf("WebKit"),_5.indexOf("Safari"),0);if(_15&&!_a){_c=parseFloat(_5.split("Version/")[1]);if(!_c||parseFloat(_5.substr(_15+7))<=419.3){_c=2;}}if(!_2("dojo-webkit")){if(_4.indexOf("Opera")>=0){_6=tv;if(_6>=9.8){_6=parseFloat(_4.split("Version/")[1])||tv;}}if(_4.indexOf("Gecko")>=0&&!_8&&!_9){_d=_e=tv;}if(_e){_10=parseFloat(_4.split("Firefox/")[1]||_4.split("Minefield/")[1])||undefined;}if(document.all&&!_6){_f=parseFloat(_5.split("MSIE ")[1])||undefined;var _16=document.documentMode;if(_16&&_16!=5&&Math.floor(_f)!=_16){_f=_16;}}}_11=document.compatMode=="BackCompat";_3("opera",_1.isOpera=_6);_3("air",_1.isAIR=_7);_3("khtml",_1.isKhtml=_8);_3("webkit",_1.isWebKit=_9);_3("chrome",_1.isChrome=_a);_3("mac",_1.isMac=_b);_3("safari",_1.isSafari=_c);_3("mozilla",_1.isMozilla=_1.isMoz=_d);_3("ie",_1.isIE=_f);_3("ff",_1.isFF=_10);_3("quirks",_1.isQuirks=_11);_3("ios",_1.isIos=_12);_3("android",_1.isAndroid=_13);_1.locale=_1.locale||(_f?n.userLanguage:n.language).toLowerCase();return _2;});
\ No newline at end of file
diff --git a/lib/dojo/_base/sniff.js.uncompressed.js b/lib/dojo/_base/sniff.js.uncompressed.js
new file mode 100644
index 000000000..c7e4b428a
--- /dev/null
+++ b/lib/dojo/_base/sniff.js.uncompressed.js
@@ -0,0 +1,187 @@
+define("dojo/_base/sniff", ["./kernel", "../has"], function(dojo, has){
+	// module:
+	//		dojo/sniff
+	// summary:
+	//		This module populates the dojo browser version sniffing properties.
+
+	if(!1){
+		return has;
+	}
+
+	dojo.isBrowser = true,
+	dojo._name = "browser";
+
+	var hasAdd = has.add,
+		n = navigator,
+		dua = n.userAgent,
+		dav = n.appVersion,
+		tv = parseFloat(dav),
+		isOpera,
+		isAIR,
+		isKhtml,
+		isWebKit,
+		isChrome,
+		isMac,
+		isSafari,
+		isMozilla ,
+		isMoz,
+		isIE,
+		isFF,
+		isQuirks,
+		isIos,
+		isAndroid,
+		isWii;
+
+	/*=====
+	dojo.isBrowser = {
+		//	example:
+		//	| if(dojo.isBrowser){ ... }
+	};
+
+	dojo.isFF = {
+		//	example:
+		//	| if(dojo.isFF > 1){ ... }
+	};
+
+	dojo.isIE = {
+		// example:
+		//	| if(dojo.isIE > 6){
+		//	|		// we are IE7
+		//	| }
+	};
+
+	dojo.isSafari = {
+		//	example:
+		//	| if(dojo.isSafari){ ... }
+		//	example:
+		//		Detect iPhone:
+		//	| if(dojo.isSafari && navigator.userAgent.indexOf("iPhone") != -1){
+		//	|		// we are iPhone. Note, iPod touch reports "iPod" above and fails this test.
+		//	| }
+	};
+
+	dojo.mixin(dojo, {
+		// isBrowser: Boolean
+		//		True if the client is a web-browser
+		isBrowser: true,
+		//	isFF: Number | undefined
+		//		Version as a Number if client is FireFox. undefined otherwise. Corresponds to
+		//		major detected FireFox version (1.5, 2, 3, etc.)
+		isFF: 2,
+		//	isIE: Number | undefined
+		//		Version as a Number if client is MSIE(PC). undefined otherwise. Corresponds to
+		//		major detected IE version (6, 7, 8, etc.)
+		isIE: 6,
+		//	isKhtml: Number | undefined
+		//		Version as a Number if client is a KHTML browser. undefined otherwise. Corresponds to major
+		//		detected version.
+		isKhtml: 0,
+		//	isWebKit: Number | undefined
+		//		Version as a Number if client is a WebKit-derived browser (Konqueror,
+		//		Safari, Chrome, etc.). undefined otherwise.
+		isWebKit: 0,
+		//	isMozilla: Number | undefined
+		//		Version as a Number if client is a Mozilla-based browser (Firefox,
+		//		SeaMonkey). undefined otherwise. Corresponds to major detected version.
+		isMozilla: 0,
+		//	isOpera: Number | undefined
+		//		Version as a Number if client is Opera. undefined otherwise. Corresponds to
+		//		major detected version.
+		isOpera: 0,
+		//	isSafari: Number | undefined
+		//		Version as a Number if client is Safari or iPhone. undefined otherwise.
+		isSafari: 0,
+		//	isChrome: Number | undefined
+		//		Version as a Number if client is Chrome browser. undefined otherwise.
+		isChrome: 0,
+		//	isMac: Boolean
+		//		True if the client runs on Mac
+		isMac: 0,
+		// isIos: Boolean
+		//		True if client is iPhone, iPod, or iPad
+		isIos: 0,
+		// isAndroid: Number | undefined
+		//		Version as a Number if client is android browser. undefined otherwise.
+		isAndroid: 0,
+		// isWii: Boolean
+		//		True if client is Wii
+		isWii: 0
+	});
+	=====*/
+
+	// fill in the rendering support information in dojo.render.*
+	if(dua.indexOf("AdobeAIR") >= 0){ isAIR = 1; }
+	isKhtml = (dav.indexOf("Konqueror") >= 0) ? tv : 0;
+	isWebKit = parseFloat(dua.split("WebKit/")[1]) || undefined;
+	isChrome = parseFloat(dua.split("Chrome/")[1]) || undefined;
+	isMac = dav.indexOf("Macintosh") >= 0;
+	isIos = /iPhone|iPod|iPad/.test(dua);
+	isAndroid = parseFloat(dua.split("Android ")[1]) || undefined;
+	isWii = typeof opera != "undefined" && opera.wiiremote;
+
+	// safari detection derived from:
+	//		http://developer.apple.com/internet/safari/faq.html#anchor2
+	//		http://developer.apple.com/internet/safari/uamatrix.html
+	var index = Math.max(dav.indexOf("WebKit"), dav.indexOf("Safari"), 0);
+	if(index && !isChrome){
+		// try to grab the explicit Safari version first. If we don't get
+		// one, look for less than 419.3 as the indication that we're on something
+		// "Safari 2-ish".
+		isSafari = parseFloat(dav.split("Version/")[1]);
+		if(!isSafari || parseFloat(dav.substr(index + 7)) <= 419.3){
+			isSafari = 2;
+		}
+	}
+
+	if (!has("dojo-webkit")) {
+		if(dua.indexOf("Opera") >= 0){
+			isOpera = tv;
+			// see http://dev.opera.com/articles/view/opera-ua-string-changes and http://www.useragentstring.com/pages/Opera/
+			// 9.8 has both styles; <9.8, 9.9 only old style
+			if(isOpera >= 9.8){
+				isOpera = parseFloat(dua.split("Version/")[1]) || tv;
+			}
+		}
+
+		if(dua.indexOf("Gecko") >= 0 && !isKhtml && !isWebKit){
+			isMozilla = isMoz = tv;
+		}
+		if(isMoz){
+			//We really need to get away from this. Consider a sane isGecko approach for the future.
+			isFF = parseFloat(dua.split("Firefox/")[1] || dua.split("Minefield/")[1]) || undefined;
+		}
+		if(document.all && !isOpera){
+			isIE = parseFloat(dav.split("MSIE ")[1]) || undefined;
+			//In cases where the page has an HTTP header or META tag with
+			//X-UA-Compatible, then it is in emulation mode.
+			//Make sure isIE reflects the desired version.
+			//document.documentMode of 5 means quirks mode.
+			//Only switch the value if documentMode's major version
+			//is different from isIE's major version.
+			var mode = document.documentMode;
+			if(mode && mode != 5 && Math.floor(isIE) != mode){
+				isIE = mode;
+			}
+		}
+	}
+
+	isQuirks = document.compatMode == "BackCompat";
+
+	hasAdd("opera", dojo.isOpera = isOpera);
+	hasAdd("air", dojo.isAIR = isAIR);
+	hasAdd("khtml", dojo.isKhtml = isKhtml);
+	hasAdd("webkit", dojo.isWebKit = isWebKit);
+	hasAdd("chrome", dojo.isChrome = isChrome);
+	hasAdd("mac", dojo.isMac = isMac );
+	hasAdd("safari", dojo.isSafari = isSafari);
+	hasAdd("mozilla", dojo.isMozilla = dojo.isMoz = isMozilla );
+	hasAdd("ie", dojo.isIE = isIE );
+	hasAdd("ff", dojo.isFF = isFF);
+	hasAdd("quirks", dojo.isQuirks = isQuirks);
+	hasAdd("ios", dojo.isIos = isIos);
+	hasAdd("android", dojo.isAndroid = isAndroid);
+
+	dojo.locale = dojo.locale || (isIE ? n.userLanguage : n.language).toLowerCase();
+
+	return has;
+});
diff --git a/lib/dojo/_base/unload.js b/lib/dojo/_base/unload.js
new file mode 100644
index 000000000..8e099ae14
--- /dev/null
+++ b/lib/dojo/_base/unload.js
@@ -0,0 +1,8 @@
+/*
+	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
+*/
+
+//>>built
+define("dojo/_base/unload",["./kernel","./connect"],function(_1,_2){var _3=window;_1.addOnWindowUnload=function(_4,_5){if(!_1.windowUnloaded){_2.connect(_3,"unload",(_1.windowUnloaded=function(){}));}_2.connect(_3,"unload",_4,_5);};_1.addOnUnload=function(_6,_7){_2.connect(_3,"beforeunload",_6,_7);};return {addOnWindowUnload:_1.addOnWindowUnload,addOnUnload:_1.addOnUnload};});
\ No newline at end of file
diff --git a/lib/dojo/_base/unload.js.uncompressed.js b/lib/dojo/_base/unload.js.uncompressed.js
new file mode 100644
index 000000000..e811d929d
--- /dev/null
+++ b/lib/dojo/_base/unload.js.uncompressed.js
@@ -0,0 +1,81 @@
+define("dojo/_base/unload", ["./kernel", "./connect"], function(dojo, connect) {
+	// module:
+	//		dojo/unload
+	// summary:
+	//		This module contains the document and window unload detection API.
+
+	var win = window;
+
+	/*=====
+		dojo.windowUnloaded = function(){
+			// summary:
+			//		signal fired by impending window destruction. You may use
+			//		dojo.addOnWindowUnload() to register a listener for this
+			//		event. NOTE: if you wish to dojo.connect() to this method
+			//		to perform page/application cleanup, be aware that this
+			//		event WILL NOT fire if no handler has been registered with
+			//		dojo.addOnWindowUnload. This behavior started in Dojo 1.3.
+			//		Previous versions always triggered dojo.windowUnloaded. See
+			//		dojo.addOnWindowUnload for more info.
+		};
+	=====*/
+
+	dojo.addOnWindowUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){
+		// summary:
+		//		registers a function to be triggered when window.onunload
+		//		fires.
+		//	description:
+		//		The first time that addOnWindowUnload is called Dojo
+		//		will register a page listener to trigger your unload
+		//		handler with. Note that registering these handlers may
+		//		destory "fastback" page caching in browsers that support
+		//		it. Be careful trying to modify the DOM or access
+		//		JavaScript properties during this phase of page unloading:
+		//		they may not always be available. Consider
+		//		dojo.addOnUnload() if you need to modify the DOM or do
+		//		heavy JavaScript work since it fires at the eqivalent of
+		//		the page's "onbeforeunload" event.
+		// example:
+		//	| dojo.addOnWindowUnload(functionPointer)
+		//	| dojo.addOnWindowUnload(object, "functionName");
+		//	| dojo.addOnWindowUnload(object, function(){ /* ... */});
+
+		if (!dojo.windowUnloaded) {
+			connect.connect(win, "unload", (dojo.windowUnloaded= function(){}));
+		}
+		connect.connect(win, "unload", obj, functionName);
+	};
+
+	dojo.addOnUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){
+		// summary:
+		//		registers a function to be triggered when the page unloads.
+		//	description:
+		//		The first time that addOnUnload is called Dojo will
+		//		register a page listener to trigger your unload handler
+		//		with.
+		//
+		//		In a browser enviroment, the functions will be triggered
+		//		during the window.onbeforeunload event. Be careful of doing
+		//		too much work in an unload handler. onbeforeunload can be
+		//		triggered if a link to download a file is clicked, or if
+		//		the link is a javascript: link. In these cases, the
+		//		onbeforeunload event fires, but the document is not
+		//		actually destroyed. So be careful about doing destructive
+		//		operations in a dojo.addOnUnload callback.
+		//
+		//		Further note that calling dojo.addOnUnload will prevent
+		//		browsers from using a "fast back" cache to make page
+		//		loading via back button instantaneous.
+		// example:
+		//	| dojo.addOnUnload(functionPointer)
+		//	| dojo.addOnUnload(object, "functionName")
+		//	| dojo.addOnUnload(object, function(){ /* ... */});
+
+		connect.connect(win, "beforeunload", obj, functionName);
+	};
+
+	return {
+		addOnWindowUnload: dojo.addOnWindowUnload,
+		addOnUnload: dojo.addOnUnload
+	};
+});
diff --git a/lib/dojo/_base/url.js b/lib/dojo/_base/url.js
new file mode 100644
index 000000000..41bae092c
--- /dev/null
+++ b/lib/dojo/_base/url.js
@@ -0,0 +1,8 @@
+/*
+	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
+*/
+
+//>>built
+define("dojo/_base/url",["./kernel"],function(_1){var _2=new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"),_3=new RegExp("^((([^\\[:]+):)?([^@]+)@)?(\\[([^\\]]+)\\]|([^\\[:]*))(:([0-9]+))?$"),_4=function(){var n=null,_5=arguments,_6=[_5[0]];for(var i=1;i<_5.length;i++){if(!_5[i]){continue;}var _7=new _4(_5[i]+""),_8=new _4(_6[0]+"");if(_7.path==""&&!_7.scheme&&!_7.authority&&!_7.query){if(_7.fragment!=n){_8.fragment=_7.fragment;}_7=_8;}else{if(!_7.scheme){_7.scheme=_8.scheme;if(!_7.authority){_7.authority=_8.authority;if(_7.path.charAt(0)!="/"){var _9=_8.path.substring(0,_8.path.lastIndexOf("/")+1)+_7.path;var _a=_9.split("/");for(var j=0;j<_a.length;j++){if(_a[j]=="."){if(j==_a.length-1){_a[j]="";}else{_a.splice(j,1);j--;}}else{if(j>0&&!(j==1&&_a[0]=="")&&_a[j]==".."&&_a[j-1]!=".."){if(j==(_a.length-1)){_a.splice(j,1);_a[j-1]="";}else{_a.splice(j-1,2);j-=2;}}}}_7.path=_a.join("/");}}}}_6=[];if(_7.scheme){_6.push(_7.scheme,":");}if(_7.authority){_6.push("//",_7.authority);}_6.push(_7.path);if(_7.query){_6.push("?",_7.query);}if(_7.fragment){_6.push("#",_7.fragment);}}this.uri=_6.join("");var r=this.uri.match(_2);this.scheme=r[2]||(r[1]?"":n);this.authority=r[4]||(r[3]?"":n);this.path=r[5];this.query=r[7]||(r[6]?"":n);this.fragment=r[9]||(r[8]?"":n);if(this.authority!=n){r=this.authority.match(_3);this.user=r[3]||n;this.password=r[4]||n;this.host=r[6]||r[7];this.port=r[9]||n;}};_4.prototype.toString=function(){return this.uri;};return _1._Url=_4;});
\ No newline at end of file
diff --git a/lib/dojo/_base/url.js.uncompressed.js b/lib/dojo/_base/url.js.uncompressed.js
new file mode 100644
index 000000000..73f447b54
--- /dev/null
+++ b/lib/dojo/_base/url.js.uncompressed.js
@@ -0,0 +1,111 @@
+define("dojo/_base/url", ["./kernel"], function(dojo) {
+	// module:
+	//		dojo/url
+	// summary:
+	//		This module contains dojo._Url
+
+	var
+		ore = new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"),
+		ire = new RegExp("^((([^\\[:]+):)?([^@]+)@)?(\\[([^\\]]+)\\]|([^\\[:]*))(:([0-9]+))?$"),
+		_Url = function(){
+			var n = null,
+				_a = arguments,
+				uri = [_a[0]];
+			// resolve uri components relative to each other
+			for(var i = 1; i<_a.length; i++){
+				if(!_a[i]){ continue; }
+
+				// Safari doesn't support this.constructor so we have to be explicit
+				// FIXME: Tracked (and fixed) in Webkit bug 3537.
+				//		http://bugs.webkit.org/show_bug.cgi?id=3537
+				var relobj = new _Url(_a[i]+""),
+					uriobj = new _Url(uri[0]+"");
+
+				if(
+					relobj.path == "" &&
+					!relobj.scheme &&
+					!relobj.authority &&
+					!relobj.query
+				){
+					if(relobj.fragment != n){
+						uriobj.fragment = relobj.fragment;
+					}
+					relobj = uriobj;
+				}else if(!relobj.scheme){
+					relobj.scheme = uriobj.scheme;
+
+					if(!relobj.authority){
+						relobj.authority = uriobj.authority;
+
+						if(relobj.path.charAt(0) != "/"){
+							var path = uriobj.path.substring(0,
+								uriobj.path.lastIndexOf("/") + 1) + relobj.path;
+
+							var segs = path.split("/");
+							for(var j = 0; j < segs.length; j++){
+								if(segs[j] == "."){
+									// flatten "./" references
+									if(j == segs.length - 1){
+										segs[j] = "";
+									}else{
+										segs.splice(j, 1);
+										j--;
+									}
+								}else if(j > 0 && !(j == 1 && segs[0] == "") &&
+									segs[j] == ".." && segs[j-1] != ".."){
+									// flatten "../" references
+									if(j == (segs.length - 1)){
+										segs.splice(j, 1);
+										segs[j - 1] = "";
+									}else{
+										segs.splice(j - 1, 2);
+										j -= 2;
+									}
+								}
+							}
+							relobj.path = segs.join("/");
+						}
+					}
+				}
+
+				uri = [];
+				if(relobj.scheme){
+					uri.push(relobj.scheme, ":");
+				}
+				if(relobj.authority){
+					uri.push("//", relobj.authority);
+				}
+				uri.push(relobj.path);
+				if(relobj.query){
+					uri.push("?", relobj.query);
+				}
+				if(relobj.fragment){
+					uri.push("#", relobj.fragment);
+				}
+			}
+
+			this.uri = uri.join("");
+
+			// break the uri into its main components
+			var r = this.uri.match(ore);
+
+			this.scheme = r[2] || (r[1] ? "" : n);
+			this.authority = r[4] || (r[3] ? "" : n);
+			this.path = r[5]; // can never be undefined
+			this.query = r[7] || (r[6] ? "" : n);
+			this.fragment	 = r[9] || (r[8] ? "" : n);
+
+			if(this.authority != n){
+				// server based naming authority
+				r = this.authority.match(ire);
+
+				this.user = r[3] || n;
+				this.password = r[4] || n;
+				this.host = r[6] || r[7]; // ipv6 || ipv4
+				this.port = r[9] || n;
+			}
+		};
+	_Url.prototype.toString = function(){ return this.uri; };
+
+	return dojo._Url = _Url;
+});
diff --git a/lib/dojo/_base/window.js b/lib/dojo/_base/window.js
index 143bad610..7082cb077 100644
--- a/lib/dojo/_base/window.js
+++ b/lib/dojo/_base/window.js
@@ -4,105 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.window"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.window"] = true;
-dojo.provide("dojo._base.window");
-
-
-/*=====
-dojo.doc = {
-	// summary:
-	//		Alias for the current document. 'dojo.doc' can be modified
-	//		for temporary context shifting. Also see dojo.withDoc().
-	// description:
-	//    Refer to dojo.doc rather
-	//    than referring to 'window.document' to ensure your code runs
-	//    correctly in managed contexts.
-	// example:
-	// 	|	n.appendChild(dojo.doc.createElement('div'));
-}
-=====*/
-dojo.doc = window["document"] || null;
-
-dojo.body = function(){
-	// summary:
-	//		Return the body element of the document
-	//		return the body object associated with dojo.doc
-	// example:
-	// 	|	dojo.body().appendChild(dojo.doc.createElement('div'));
-
-	// Note: document.body is not defined for a strict xhtml document
-	// Would like to memoize this, but dojo.doc can change vi dojo.withDoc().
-	return dojo.doc.body || dojo.doc.getElementsByTagName("body")[0]; // Node
-};
-
-dojo.setContext = function(/*Object*/globalObject, /*DocumentElement*/globalDocument){
-	// summary:
-	//		changes the behavior of many core Dojo functions that deal with
-	//		namespace and DOM lookup, changing them to work in a new global
-	//		context (e.g., an iframe). The varibles dojo.global and dojo.doc
-	//		are modified as a result of calling this function and the result of
-	//		`dojo.body()` likewise differs.
-	dojo.global = globalObject;
-	dojo.doc = globalDocument;
-};
-
-dojo.withGlobal = function(	/*Object*/globalObject,
-							/*Function*/callback,
-							/*Object?*/thisObject,
-							/*Array?*/cbArguments){
-	// summary:
-	//		Invoke callback with globalObject as dojo.global and
-	//		globalObject.document as dojo.doc.
-	// description:
-	//		Invoke callback with globalObject as dojo.global and
-	//		globalObject.document as dojo.doc. If provided, globalObject
-	//		will be executed in the context of object thisObject
-	//		When callback() returns or throws an error, the dojo.global
-	//		and dojo.doc will be restored to its previous state.
-
-	var oldGlob = dojo.global;
-	try{
-		dojo.global = globalObject;
-		return dojo.withDoc.call(null, globalObject.document, callback, thisObject, cbArguments);
-	}finally{
-		dojo.global = oldGlob;
-	}
-};
-
-dojo.withDoc = function(	/*DocumentElement*/documentObject,
-							/*Function*/callback,
-							/*Object?*/thisObject,
-							/*Array?*/cbArguments){
-	// summary:
-	//		Invoke callback with documentObject as dojo.doc.
-	// description:
-	//		Invoke callback with documentObject as dojo.doc. If provided,
-	//		callback will be executed in the context of object thisObject
-	//		When callback() returns or throws an error, the dojo.doc will
-	//		be restored to its previous state.
-
-	var oldDoc = dojo.doc,
-		oldLtr = dojo._bodyLtr,
-		oldQ = dojo.isQuirks;
-
-	try{
-		dojo.doc = documentObject;
-		delete dojo._bodyLtr; // uncache
-		dojo.isQuirks = dojo.doc.compatMode == "BackCompat"; // no need to check for QuirksMode which was Opera 7 only
-
-		if(thisObject && typeof callback == "string"){
-			callback = thisObject[callback];
-		}
-
-		return callback.apply(thisObject, cbArguments || []);
-	}finally{
-		dojo.doc = oldDoc;
-		delete dojo._bodyLtr; // in case it was undefined originally, and set to true/false by the alternate document
-		if(oldLtr !== undefined){ dojo._bodyLtr = oldLtr; }
-		dojo.isQuirks = oldQ;
-	}
-};
-
-}
+//>>built
+define("dojo/_base/window",["./kernel","../has","./sniff"],function(_1,_2){_1.doc=this["document"]||null;_1.body=function(){return _1.doc.body||_1.doc.getElementsByTagName("body")[0];};_1.setContext=function(_3,_4){_1.global=_5.global=_3;_1.doc=_5.doc=_4;};_1.withGlobal=function(_6,_7,_8,_9){var _a=_1.global;try{_1.global=_5.global=_6;return _1.withDoc.call(null,_6.document,_7,_8,_9);}finally{_1.global=_5.global=_a;}};_1.withDoc=function(_b,_c,_d,_e){var _f=_1.doc,_10=_1.isQuirks,_11=_1.isIE,_12,_13,_14;try{_1.doc=_5.doc=_b;_1.isQuirks=_2.add("quirks",_1.doc.compatMode=="BackCompat",true,true);if(_2("ie")){if((_14=_b.parentWindow)&&_14.navigator){_12=parseFloat(_14.navigator.appVersion.split("MSIE ")[1])||undefined;_13=_b.documentMode;if(_13&&_13!=5&&Math.floor(_12)!=_13){_12=_13;}_1.isIE=_2.add("ie",_12,true,true);}}if(_d&&typeof _c=="string"){_c=_d[_c];}return _c.apply(_d,_e||[]);}finally{_1.doc=_5.doc=_f;_1.isQuirks=_2.add("quirks",_10,true,true);_1.isIE=_2.add("ie",_11,true,true);}};var _5={global:_1.global,doc:_1.doc,body:_1.body,setContext:_1.setContext,withGlobal:_1.withGlobal,withDoc:_1.withDoc};return _5;});
\ No newline at end of file
diff --git a/lib/dojo/_base/window.js.uncompressed.js b/lib/dojo/_base/window.js.uncompressed.js
new file mode 100644
index 000000000..0c9f236b6
--- /dev/null
+++ b/lib/dojo/_base/window.js.uncompressed.js
@@ -0,0 +1,126 @@
+define("dojo/_base/window", ["./kernel", "../has", "./sniff"], function(dojo, has){
+	// module:
+	//		dojo/window
+	// summary:
+	//		This module provides an API to save/set/restore the global/document scope.
+
+/*=====
+dojo.doc = {
+	// summary:
+	//		Alias for the current document. 'dojo.doc' can be modified
+	//		for temporary context shifting. Also see dojo.withDoc().
+	// description:
+	//		Refer to dojo.doc rather
+	//		than referring to 'window.document' to ensure your code runs
+	//		correctly in managed contexts.
+	// example:
+	//	|	n.appendChild(dojo.doc.createElement('div'));
+}
+=====*/
+dojo.doc = this["document"] || null;
+
+dojo.body = function(){
+	// summary:
+	//		Return the body element of the document
+	//		return the body object associated with dojo.doc
+	// example:
+	//	|	dojo.body().appendChild(dojo.doc.createElement('div'));
+
+	// Note: document.body is not defined for a strict xhtml document
+	// Would like to memoize this, but dojo.doc can change vi dojo.withDoc().
+	return dojo.doc.body || dojo.doc.getElementsByTagName("body")[0]; // Node
+};
+
+dojo.setContext = function(/*Object*/globalObject, /*DocumentElement*/globalDocument){
+	// summary:
+	//		changes the behavior of many core Dojo functions that deal with
+	//		namespace and DOM lookup, changing them to work in a new global
+	//		context (e.g., an iframe). The varibles dojo.global and dojo.doc
+	//		are modified as a result of calling this function and the result of
+	//		`dojo.body()` likewise differs.
+	dojo.global = ret.global = globalObject;
+	dojo.doc = ret.doc = globalDocument;
+};
+
+dojo.withGlobal = function(	/*Object*/globalObject,
+							/*Function*/callback,
+							/*Object?*/thisObject,
+							/*Array?*/cbArguments){
+	// summary:
+	//		Invoke callback with globalObject as dojo.global and
+	//		globalObject.document as dojo.doc.
+	// description:
+	//		Invoke callback with globalObject as dojo.global and
+	//		globalObject.document as dojo.doc. If provided, globalObject
+	//		will be executed in the context of object thisObject
+	//		When callback() returns or throws an error, the dojo.global
+	//		and dojo.doc will be restored to its previous state.
+
+	var oldGlob = dojo.global;
+	try{
+		dojo.global = ret.global = globalObject;
+		return dojo.withDoc.call(null, globalObject.document, callback, thisObject, cbArguments);
+	}finally{
+		dojo.global = ret.global = oldGlob;
+	}
+};
+
+dojo.withDoc = function(	/*DocumentElement*/documentObject,
+							/*Function*/callback,
+							/*Object?*/thisObject,
+							/*Array?*/cbArguments){
+	// summary:
+	//		Invoke callback with documentObject as dojo.doc.
+	// description:
+	//		Invoke callback with documentObject as dojo.doc. If provided,
+	//		callback will be executed in the context of object thisObject
+	//		When callback() returns or throws an error, the dojo.doc will
+	//		be restored to its previous state.
+
+	var oldDoc = dojo.doc,
+		oldQ = dojo.isQuirks,
+		oldIE = dojo.isIE, isIE, mode, pwin;
+
+	try{
+		dojo.doc = ret.doc = documentObject;
+		// update dojo.isQuirks and the value of the has feature "quirks"
+		dojo.isQuirks = has.add("quirks", dojo.doc.compatMode == "BackCompat", true, true); // no need to check for QuirksMode which was Opera 7 only
+
+		if(has("ie")){
+			if((pwin = documentObject.parentWindow) && pwin.navigator){
+				// re-run IE detection logic and update dojo.isIE / has("ie")
+				// (the only time parentWindow/navigator wouldn't exist is if we were not
+				// passed an actual legitimate document object)
+				isIE = parseFloat(pwin.navigator.appVersion.split("MSIE ")[1]) || undefined;
+				mode = documentObject.documentMode;
+				if(mode && mode != 5 && Math.floor(isIE) != mode){
+					isIE = mode;
+				}
+				dojo.isIE = has.add("ie", isIE, true, true);
+			}
+		}
+
+		if(thisObject && typeof callback == "string"){
+			callback = thisObject[callback];
+		}
+
+		return callback.apply(thisObject, cbArguments || []);
+	}finally{
+		dojo.doc = ret.doc = oldDoc;
+		dojo.isQuirks = has.add("quirks", oldQ, true, true);
+		dojo.isIE = has.add("ie", oldIE, true, true);
+	}
+};
+
+var ret = {
+	global: dojo.global,
+	doc: dojo.doc,
+	body: dojo.body,
+	setContext: dojo.setContext,
+	withGlobal: dojo.withGlobal,
+	withDoc: dojo.withDoc
+};
+
+return ret;
+
+});
diff --git a/lib/dojo/_base/xhr.js b/lib/dojo/_base/xhr.js
index 58f1fdb62..ee38dbd4f 100644
--- a/lib/dojo/_base/xhr.js
+++ b/lib/dojo/_base/xhr.js
@@ -4,939 +4,5 @@
 	see: http://dojotoolkit.org/license for details
 */
 
-
-if(!dojo._hasResource["dojo._base.xhr"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
-dojo._hasResource["dojo._base.xhr"] = true;
-dojo.provide("dojo._base.xhr");
-dojo.require("dojo._base.Deferred");
-dojo.require("dojo._base.json");
-dojo.require("dojo._base.lang");
-dojo.require("dojo._base.query");
-
-
-(function(){
-	var _d = dojo, cfg = _d.config;
-
-	function setValue(/*Object*/obj, /*String*/name, /*String*/value){
-		//summary:
-		//		For the named property in object, set the value. If a value
-		//		already exists and it is a string, convert the value to be an
-		//		array of values.
-
-		//Skip it if there is no value
-		if(value === null){
-			return;
-		}
-
-		var val = obj[name];
-		if(typeof val == "string"){ // inline'd type check
-			obj[name] = [val, value];
-		}else if(_d.isArray(val)){
-			val.push(value);
-		}else{
-			obj[name] = value;
-		}
-	}
-	
-	dojo.fieldToObject = function(/*DOMNode||String*/ inputNode){
-		// summary:
-		//		Serialize a form field to a JavaScript object.
-		//
-		// description:
-		//		Returns the value encoded in a form field as
-		//		as a string or an array of strings. Disabled form elements
-		//		and unchecked radio and checkboxes are skipped.	Multi-select
-		//		elements are returned as an array of string values.
-		var ret = null;
-		var item = _d.byId(inputNode);
-		if(item){
-			var _in = item.name;
-			var type = (item.type||"").toLowerCase();
-			if(_in && type && !item.disabled){
-				if(type == "radio" || type == "checkbox"){
-					if(item.checked){ ret = item.value; }
-				}else if(item.multiple){
-					ret = [];
-					_d.query("option", item).forEach(function(opt){
-						if(opt.selected){
-							ret.push(opt.value);
-						}
-					});
-				}else{
-					ret = item.value;
-				}
-			}
-		}
-		return ret; // Object
-	};
-
-	dojo.formToObject = function(/*DOMNode||String*/ formNode){
-		// summary:
-		//		Serialize a form node to a JavaScript object.
-		// description:
-		//		Returns the values encoded in an HTML form as
-		//		string properties in an object which it then returns. Disabled form
-		//		elements, buttons, and other non-value form elements are skipped.
-		//		Multi-select elements are returned as an array of string values.
-		//
-		// example:
-		//		This form:
-		//		|	<form id="test_form">
-		//		|		<input type="text" name="blah" value="blah">
-		//		|		<input type="text" name="no_value" value="blah" disabled>
-		//		|		<input type="button" name="no_value2" value="blah">
-		//		|		<select type="select" multiple name="multi" size="5">
-		//		|			<option value="blah">blah</option>
-		//		|			<option value="thud" selected>thud</option>
-		//		|			<option value="thonk" selected>thonk</option>
-		//		|		</select>
-		//		|	</form>
-		//
-		//		yields this object structure as the result of a call to
-		//		formToObject():
-		//
-		//		|	{
-		//		|		blah: "blah",
-		//		|		multi: [
-		//		|			"thud",
-		//		|			"thonk"
-		//		|		]
-		//		|	};
-
-		var ret = {};
-		var exclude = "file|submit|image|reset|button|";
-		_d.forEach(dojo.byId(formNode).elements, function(item){
-			var _in = item.name;
-			var type = (item.type||"").toLowerCase();
-			if(_in && type && exclude.indexOf(type) == -1 && !item.disabled){
-				setValue(ret, _in, _d.fieldToObject(item));
-				if(type == "image"){
-					ret[_in+".x"] = ret[_in+".y"] = ret[_in].x = ret[_in].y = 0;
-				}
-			}
-		});
-		return ret; // Object
-	};
-
-	dojo.objectToQuery = function(/*Object*/ map){
-		//	summary:
-		//		takes a name/value mapping object and returns a string representing
-		//		a URL-encoded version of that object.
-		//	example:
-		//		this object:
-		//
-		//		|	{
-		//		|		blah: "blah",
-		//		|		multi: [
-		//		|			"thud",
-		//		|			"thonk"
-		//		|		]
-		//		|	};
-		//
-		//	yields the following query string:
-		//
-		//	|	"blah=blah&multi=thud&multi=thonk"
-
-		// FIXME: need to implement encodeAscii!!
-		var enc = encodeURIComponent;
-		var pairs = [];
-		var backstop = {};
-		for(var name in map){
-			var value = map[name];
-			if(value != backstop[name]){
-				var assign = enc(name) + "=";
-				if(_d.isArray(value)){
-					for(var i=0; i < value.length; i++){
-						pairs.push(assign + enc(value[i]));
-					}
-				}else{
-					pairs.push(assign + enc(value));
-				}
-			}
-		}
-		return pairs.join("&"); // String
-	};
-
-	dojo.formToQuery = function(/*DOMNode||String*/ formNode){
-		// summary:
-		//		Returns a URL-encoded string representing the form passed as either a
-		//		node or string ID identifying the form to serialize
-		return _d.objectToQuery(_d.formToObject(formNode)); // String
-	};
-
-	dojo.formToJson = function(/*DOMNode||String*/ formNode, /*Boolean?*/prettyPrint){
-		// summary:
-		//		Create a serialized JSON string from a form node or string
-		//		ID identifying the form to serialize
-		return _d.toJson(_d.formToObject(formNode), prettyPrint); // String
-	};
-
-	dojo.queryToObject = function(/*String*/ str){
-		// summary:
-		//		Create an object representing a de-serialized query section of a
-		//		URL. Query keys with multiple values are returned in an array.
-		//
-		// example:
-		//		This string:
-		//
-		//	|		"foo=bar&foo=baz&thinger=%20spaces%20=blah&zonk=blarg&"
-		//
-		//		results in this object structure:
-		//
-		//	|		{
-		//	|			foo: [ "bar", "baz" ],
-		//	|			thinger: " spaces =blah",
-		//	|			zonk: "blarg"
-		//	|		}
-		//
-		//		Note that spaces and other urlencoded entities are correctly
-		//		handled.
-
-		// FIXME: should we grab the URL string if we're not passed one?
-		var ret = {};
-		var qp = str.split("&");
-		var dec = decodeURIComponent;
-		_d.forEach(qp, function(item){
-			if(item.length){
-				var parts = item.split("=");
-				var name = dec(parts.shift());
-				var val = dec(parts.join("="));
-				if(typeof ret[name] == "string"){ // inline'd type check
-					ret[name] = [ret[name]];
-				}
-
-				if(_d.isArray(ret[name])){
-					ret[name].push(val);
-				}else{
-					ret[name] = val;
-				}
-			}
-		});
-		return ret; // Object
-	};
-
-	// need to block async callbacks from snatching this thread as the result
-	// of an async callback might call another sync XHR, this hangs khtml forever
-	// must checked by watchInFlight()
-
-	dojo._blockAsync = false;
-
-	// MOW: remove dojo._contentHandlers alias in 2.0
-	var handlers = _d._contentHandlers = dojo.contentHandlers = {
-		// summary:
-		//		A map of availble XHR transport handle types. Name matches the
-		//		`handleAs` attribute passed to XHR calls.
-		//
-		// description:
-		//		A map of availble XHR transport handle types. Name matches the
-		//		`handleAs` attribute passed to XHR calls. Each contentHandler is
-		//		called, passing the xhr object for manipulation. The return value
-		//		from the contentHandler will be passed to the `load` or `handle`
-		//		functions defined in the original xhr call.
-		//
-		// example:
-		//		Creating a custom content-handler:
-		//	|	dojo.contentHandlers.makeCaps = function(xhr){
-		//	|		return xhr.responseText.toUpperCase();
-		//	|	}
-		//	|	// and later:
-		//	|	dojo.xhrGet({
-		//	|		url:"foo.txt",
-		//	|		handleAs:"makeCaps",
-		//	|		load: function(data){ /* data is a toUpper version of foo.txt */ }
-		//	|	});
-
-		text: function(xhr){
-			// summary: A contentHandler which simply returns the plaintext response data
-			return xhr.responseText;
-		},
-		json: function(xhr){
-			// summary: A contentHandler which returns a JavaScript object created from the response data
-			return _d.fromJson(xhr.responseText || null);
-		},
-		"json-comment-filtered": function(xhr){
-			// summary: A contentHandler which expects comment-filtered JSON.
-			// description:
-			//		A contentHandler which expects comment-filtered JSON.
-			//		the json-comment-filtered option was implemented to prevent
-			//		"JavaScript Hijacking", but it is less secure than standard JSON. Use
-			//		standard JSON instead. JSON prefixing can be used to subvert hijacking.
-			//
-			//		Will throw a notice suggesting to use application/json mimetype, as
-			//		json-commenting can introduce security issues. To decrease the chances of hijacking,
-			//		use the standard `json` contentHandler, and prefix your "JSON" with: {}&&
-			//
-			//		use djConfig.useCommentedJson = true to turn off the notice
-			if(!dojo.config.useCommentedJson){
-				console.warn("Consider using the standard mimetype:application/json."
-					+ " json-commenting can introduce security issues. To"
-					+ " decrease the chances of hijacking, use the standard the 'json' handler and"
-					+ " prefix your json with: {}&&\n"
-					+ "Use djConfig.useCommentedJson=true to turn off this message.");
-			}
-
-			var value = xhr.responseText;
-			var cStartIdx = value.indexOf("\/*");
-			var cEndIdx = value.lastIndexOf("*\/");
-			if(cStartIdx == -1 || cEndIdx == -1){
-				throw new Error("JSON was not comment filtered");
-			}
-			return _d.fromJson(value.substring(cStartIdx+2, cEndIdx));
-		},
-		javascript: function(xhr){
-			// summary: A contentHandler which evaluates the response data, expecting it to be valid JavaScript
-
-			// FIXME: try Moz and IE specific eval variants?
-			return _d.eval(xhr.responseText);
-		},
-		xml: function(xhr){
-			// summary: A contentHandler returning an XML Document parsed from the response data
-			var result = xhr.responseXML;
-						if(_d.isIE && (!result || !result.documentElement)){
-				//WARNING: this branch used by the xml handling in dojo.io.iframe,
-				//so be sure to test dojo.io.iframe if making changes below.
-				var ms = function(n){ return "MSXML" + n + ".DOMDocument"; };
-				var dp = ["Microsoft.XMLDOM", ms(6), ms(4), ms(3), ms(2)];
-				_d.some(dp, function(p){
-					try{
-						var dom = new ActiveXObject(p);
-						dom.async = false;
-						dom.loadXML(xhr.responseText);
-						result = dom;
-					}catch(e){ return false; }
-					return true;
-				});
-			}
-						return result; // DOMDocument
-		},
-		"json-comment-optional": function(xhr){
-			// summary: A contentHandler which checks the presence of comment-filtered JSON and
-			//		alternates between the `json` and `json-comment-filtered` contentHandlers.
-			if(xhr.responseText && /^[^{\[]*\/\*/.test(xhr.responseText)){
-				return handlers["json-comment-filtered"](xhr);
-			}else{
-				return handlers["json"](xhr);
-			}
-		}
-	};
-
-	/*=====
-	dojo.__IoArgs = function(){
-		//	url: String
-		//		URL to server endpoint.
-		//	content: Object?
-		//		Contains properties with string values. These
-		//		properties will be serialized as name1=value2 and
-		//		passed in the request.
-		//	timeout: Integer?
-		//		Milliseconds to wait for the response. If this time
-		//		passes, the then error callbacks are called.
-		//	form: DOMNode?
-		//		DOM node for a form. Used to extract the form values
-		//		and send to the server.
-		//	preventCache: Boolean?
-		//		Default is false. If true, then a
-		//		"dojo.preventCache" parameter is sent in the request
-		//		with a value that changes with each request
-		//		(timestamp). Useful only with GET-type requests.
-		//	handleAs: String?
-		//		Acceptable values depend on the type of IO
-		//		transport (see specific IO calls for more information).
-		//	rawBody: String?
-		// 		Sets the raw body for an HTTP request. If this is used, then the content
-		// 		property is ignored. This is mostly useful for HTTP methods that have
-		// 		a body to their requests, like PUT or POST. This property can be used instead
-		// 		of postData and putData for dojo.rawXhrPost and dojo.rawXhrPut respectively.
-		//	ioPublish: Boolean?
-		//		Set this explicitly to false to prevent publishing of topics related to
-		// 		IO operations. Otherwise, if djConfig.ioPublish is set to true, topics
-		// 		will be published via dojo.publish for different phases of an IO operation.
-		// 		See dojo.__IoPublish for a list of topics that are published.
-		//	load: Function?
-		//		This function will be
-		//		called on a successful HTTP response code.
-		//	error: Function?
-		//		This function will
-		//		be called when the request fails due to a network or server error, the url
-		//		is invalid, etc. It will also be called if the load or handle callback throws an
-		//		exception, unless djConfig.debugAtAllCosts is true.  This allows deployed applications
-		//		to continue to run even when a logic error happens in the callback, while making
-		//		it easier to troubleshoot while in debug mode.
-		//	handle: Function?
-		//		This function will
-		//		be called at the end of every request, whether or not an error occurs.
-		this.url = url;
-		this.content = content;
-		this.timeout = timeout;
-		this.form = form;
-		this.preventCache = preventCache;
-		this.handleAs = handleAs;
-		this.ioPublish = ioPublish;
-		this.load = function(response, ioArgs){
-			// ioArgs: dojo.__IoCallbackArgs
-			//		Provides additional information about the request.
-			// response: Object
-			//		The response in the format as defined with handleAs.
-		}
-		this.error = function(response, ioArgs){
-			// ioArgs: dojo.__IoCallbackArgs
-			//		Provides additional information about the request.
-			// response: Object
-			//		The response in the format as defined with handleAs.
-		}
-		this.handle = function(loadOrError, response, ioArgs){
-			// loadOrError: String
-			//		Provides a string that tells you whether this function
-			//		was called because of success (load) or failure (error).
-			// response: Object
-			//		The response in the format as defined with handleAs.
-			// ioArgs: dojo.__IoCallbackArgs
-			//		Provides additional information about the request.
-		}
-	}
-	=====*/
-
-	/*=====
-	dojo.__IoCallbackArgs = function(args, xhr, url, query, handleAs, id, canDelete, json){
-		//	args: Object
-		//		the original object argument to the IO call.
-		//	xhr: XMLHttpRequest
-		//		For XMLHttpRequest calls only, the
-		//		XMLHttpRequest object that was used for the
-		//		request.
-		//	url: String
-		//		The final URL used for the call. Many times it
-		//		will be different than the original args.url
-		//		value.
-		//	query: String
-		//		For non-GET requests, the
-		//		name1=value1&name2=value2 parameters sent up in
-		//		the request.
-		//	handleAs: String
-		//		The final indicator on how the response will be
-		//		handled.
-		//	id: String
-		//		For dojo.io.script calls only, the internal
-		//		script ID used for the request.
-		//	canDelete: Boolean
-		//		For dojo.io.script calls only, indicates
-		//		whether the script tag that represents the
-		//		request can be deleted after callbacks have
-		//		been called. Used internally to know when
-		//		cleanup can happen on JSONP-type requests.
-		//	json: Object
-		//		For dojo.io.script calls only: holds the JSON
-		//		response for JSONP-type requests. Used
-		//		internally to hold on to the JSON responses.
-		//		You should not need to access it directly --
-		//		the same object should be passed to the success
-		//		callbacks directly.
-		this.args = args;
-		this.xhr = xhr;
-		this.url = url;
-		this.query = query;
-		this.handleAs = handleAs;
-		this.id = id;
-		this.canDelete = canDelete;
-		this.json = json;
-	}
-	=====*/
-
-
-	/*=====
-	dojo.__IoPublish = function(){
-		// 	summary:
-		// 		This is a list of IO topics that can be published
-		// 		if djConfig.ioPublish is set to true. IO topics can be
-		// 		published for any Input/Output, network operation. So,
-		// 		dojo.xhr, dojo.io.script and dojo.io.iframe can all
-		// 		trigger these topics to be published.
-		//	start: String
-		//		"/dojo/io/start" is sent when there are no outstanding IO
-		// 		requests, and a new IO request is started. No arguments
-		// 		are passed with this topic.
-		//	send: String
-		//		"/dojo/io/send" is sent whenever a new IO request is started.
-		// 		It passes the dojo.Deferred for the request with the topic.
-		//	load: String
-		//		"/dojo/io/load" is sent whenever an IO request has loaded
-		// 		successfully. It passes the response and the dojo.Deferred
-		// 		for the request with the topic.
-		//	error: String
-		//		"/dojo/io/error" is sent whenever an IO request has errored.
-		// 		It passes the error and the dojo.Deferred
-		// 		for the request with the topic.
-		//	done: String
-		//		"/dojo/io/done" is sent whenever an IO request has completed,
-		// 		either by loading or by erroring. It passes the error and
-		// 		the dojo.Deferred for the request with the topic.
-		//	stop: String
-		//		"/dojo/io/stop" is sent when all outstanding IO requests have
-		// 		finished. No arguments are passed with this topic.
-		this.start = "/dojo/io/start";
-		this.send = "/dojo/io/send";
-		this.load = "/dojo/io/load";
-		this.error = "/dojo/io/error";
-		this.done = "/dojo/io/done";
-		this.stop = "/dojo/io/stop";
-	}
-	=====*/
-
-
-	dojo._ioSetArgs = function(/*dojo.__IoArgs*/args,
-			/*Function*/canceller,
-			/*Function*/okHandler,
-			/*Function*/errHandler){
-		//	summary:
-		//		sets up the Deferred and ioArgs property on the Deferred so it
-		//		can be used in an io call.
-		//	args:
-		//		The args object passed into the public io call. Recognized properties on
-		//		the args object are:
-		//	canceller:
-		//		The canceller function used for the Deferred object. The function
-		//		will receive one argument, the Deferred object that is related to the
-		//		canceller.
-		//	okHandler:
-		//		The first OK callback to be registered with Deferred. It has the opportunity
-		//		to transform the OK response. It will receive one argument -- the Deferred
-		//		object returned from this function.
-		//	errHandler:
-		//		The first error callback to be registered with Deferred. It has the opportunity
-		//		to do cleanup on an error. It will receive two arguments: error (the
-		//		Error object) and dfd, the Deferred object returned from this function.
-
-		var ioArgs = {args: args, url: args.url};
-
-		//Get values from form if requestd.
-		var formObject = null;
-		if(args.form){
-			var form = _d.byId(args.form);
-			//IE requires going through getAttributeNode instead of just getAttribute in some form cases,
-			//so use it for all.  See #2844
-			var actnNode = form.getAttributeNode("action");
-			ioArgs.url = ioArgs.url || (actnNode ? actnNode.value : null);
-			formObject = _d.formToObject(form);
-		}
-
-		// set up the query params
-		var miArgs = [{}];
-	
-		if(formObject){
-			// potentially over-ride url-provided params w/ form values
-			miArgs.push(formObject);
-		}
-		if(args.content){
-			// stuff in content over-rides what's set by form
-			miArgs.push(args.content);
-		}
-		if(args.preventCache){
-			miArgs.push({"dojo.preventCache": new Date().valueOf()});
-		}
-		ioArgs.query = _d.objectToQuery(_d.mixin.apply(null, miArgs));
-	
-		// .. and the real work of getting the deferred in order, etc.
-		ioArgs.handleAs = args.handleAs || "text";
-		var d = new _d.Deferred(canceller);
-		d.addCallbacks(okHandler, function(error){
-			return errHandler(error, d);
-		});
-
-		//Support specifying load, error and handle callback functions from the args.
-		//For those callbacks, the "this" object will be the args object.
-		//The callbacks will get the deferred result value as the
-		//first argument and the ioArgs object as the second argument.
-		var ld = args.load;
-		if(ld && _d.isFunction(ld)){
-			d.addCallback(function(value){
-				return ld.call(args, value, ioArgs);
-			});
-		}
-		var err = args.error;
-		if(err && _d.isFunction(err)){
-			d.addErrback(function(value){
-				return err.call(args, value, ioArgs);
-			});
-		}
-		var handle = args.handle;
-		if(handle && _d.isFunction(handle)){
-			d.addBoth(function(value){
-				return handle.call(args, value, ioArgs);
-			});
-		}
-
-		//Plug in topic publishing, if dojo.publish is loaded.
-		if(cfg.ioPublish && _d.publish && ioArgs.args.ioPublish !== false){
-			d.addCallbacks(
-				function(res){
-					_d.publish("/dojo/io/load", [d, res]);
-					return res;
-				},
-				function(res){
-					_d.publish("/dojo/io/error", [d, res]);
-					return res;
-				}
-			);
-			d.addBoth(function(res){
-				_d.publish("/dojo/io/done", [d, res]);
-				return res;
-			});
-		}
-
-		d.ioArgs = ioArgs;
-	
-		// FIXME: need to wire up the xhr object's abort method to something
-		// analagous in the Deferred
-		return d;
-	};
-
-	var _deferredCancel = function(/*Deferred*/dfd){
-		// summary: canceller function for dojo._ioSetArgs call.
-		
-		dfd.canceled = true;
-		var xhr = dfd.ioArgs.xhr;
-		var _at = typeof xhr.abort;
-		if(_at == "function" || _at == "object" || _at == "unknown"){
-			xhr.abort();
-		}
-		var err = dfd.ioArgs.error;
-		if(!err){
-			err = new Error("xhr cancelled");
-			err.dojoType="cancel";
-		}
-		return err;
-	};
-	var _deferredOk = function(/*Deferred*/dfd){
-		// summary: okHandler function for dojo._ioSetArgs call.
-
-		var ret = handlers[dfd.ioArgs.handleAs](dfd.ioArgs.xhr);
-		return ret === undefined ? null : ret;
-	};
-	var _deferError = function(/*Error*/error, /*Deferred*/dfd){
-		// summary: errHandler function for dojo._ioSetArgs call.
-
-		if(!dfd.ioArgs.args.failOk){
-			console.error(error);
-		}
-		return error;
-	};
-
-	// avoid setting a timer per request. It degrades performance on IE
-	// something fierece if we don't use unified loops.
-	var _inFlightIntvl = null;
-	var _inFlight = [];
-	
-	
-	//Use a separate count for knowing if we are starting/stopping io calls.
-	//Cannot use _inFlight.length since it can change at a different time than
-	//when we want to do this kind of test. We only want to decrement the count
-	//after a callback/errback has finished, since the callback/errback should be
-	//considered as part of finishing a request.
-	var _pubCount = 0;
-	var _checkPubCount = function(dfd){
-		if(_pubCount <= 0){
-			_pubCount = 0;
-			if(cfg.ioPublish && _d.publish && (!dfd || dfd && dfd.ioArgs.args.ioPublish !== false)){
-				_d.publish("/dojo/io/stop");
-			}
-		}
-	};
-
-	var _watchInFlight = function(){
-		//summary:
-		//		internal method that checks each inflight XMLHttpRequest to see
-		//		if it has completed or if the timeout situation applies.
-		
-		var now = (new Date()).getTime();
-		// make sure sync calls stay thread safe, if this callback is called
-		// during a sync call and this results in another sync call before the
-		// first sync call ends the browser hangs
-		if(!_d._blockAsync){
-			// we need manual loop because we often modify _inFlight (and therefore 'i') while iterating
-			// note: the second clause is an assigment on purpose, lint may complain
-			for(var i = 0, tif; i < _inFlight.length && (tif = _inFlight[i]); i++){
-				var dfd = tif.dfd;
-				var func = function(){
-					if(!dfd || dfd.canceled || !tif.validCheck(dfd)){
-						_inFlight.splice(i--, 1);
-						_pubCount -= 1;
-					}else if(tif.ioCheck(dfd)){
-						_inFlight.splice(i--, 1);
-						tif.resHandle(dfd);
-						_pubCount -= 1;
-					}else if(dfd.startTime){
-						//did we timeout?
-						if(dfd.startTime + (dfd.ioArgs.args.timeout || 0) < now){
-							_inFlight.splice(i--, 1);
-							var err = new Error("timeout exceeded");
-							err.dojoType = "timeout";
-							dfd.errback(err);
-							//Cancel the request so the io module can do appropriate cleanup.
-							dfd.cancel();
-							_pubCount -= 1;
-						}
-					}
-				};
-				if(dojo.config.debugAtAllCosts){
-					func.call(this);
-				}else{
-					try{
-						func.call(this);
-					}catch(e){
-						dfd.errback(e);
-					}
-				}
-			}
-		}
-
-		_checkPubCount(dfd);
-
-		if(!_inFlight.length){
-			clearInterval(_inFlightIntvl);
-			_inFlightIntvl = null;
-			return;
-		}
-	};
-
-	dojo._ioCancelAll = function(){
-		//summary: Cancels all pending IO requests, regardless of IO type
-		//(xhr, script, iframe).
-		try{
-			_d.forEach(_inFlight, function(i){
-				try{
-					i.dfd.cancel();
-				}catch(e){/*squelch*/}
-			});
-		}catch(e){/*squelch*/}
-	};
-
-	//Automatically call cancel all io calls on unload
-	//in IE for trac issue #2357.
-		if(_d.isIE){
-		_d.addOnWindowUnload(_d._ioCancelAll);
-	}
-	
-	_d._ioNotifyStart = function(/*Deferred*/dfd){
-		// summary:
-		// 		If dojo.publish is available, publish topics
-		// 		about the start of a request queue and/or the
-		// 		the beginning of request.
-		// description:
-		// 		Used by IO transports. An IO transport should
-		// 		call this method before making the network connection.
-		if(cfg.ioPublish && _d.publish && dfd.ioArgs.args.ioPublish !== false){
-			if(!_pubCount){
-				_d.publish("/dojo/io/start");
-			}
-			_pubCount += 1;
-			_d.publish("/dojo/io/send", [dfd]);
-		}
-	};
-
-	_d._ioWatch = function(dfd, validCheck, ioCheck, resHandle){
-		// summary:
-		//		Watches the io request represented by dfd to see if it completes.
-		// dfd: Deferred
-		//		The Deferred object to watch.
-		// validCheck: Function
-		//		Function used to check if the IO request is still valid. Gets the dfd
-		//		object as its only argument.
-		// ioCheck: Function
-		//		Function used to check if basic IO call worked. Gets the dfd
-		//		object as its only argument.
-		// resHandle: Function
-		//		Function used to process response. Gets the dfd
-		//		object as its only argument.
-		var args = dfd.ioArgs.args;
-		if(args.timeout){
-			dfd.startTime = (new Date()).getTime();
-		}
-		
-		_inFlight.push({dfd: dfd, validCheck: validCheck, ioCheck: ioCheck, resHandle: resHandle});
-		if(!_inFlightIntvl){
-			_inFlightIntvl = setInterval(_watchInFlight, 50);
-		}
-		// handle sync requests
-		//A weakness: async calls in flight
-		//could have their handlers called as part of the
-		//_watchInFlight call, before the sync's callbacks
-		// are called.
-		if(args.sync){
-			_watchInFlight();
-		}
-	};
-
-	var _defaultContentType = "application/x-www-form-urlencoded";
-
-	var _validCheck = function(/*Deferred*/dfd){
-		return dfd.ioArgs.xhr.readyState; //boolean
-	};
-	var _ioCheck = function(/*Deferred*/dfd){
-		return 4 == dfd.ioArgs.xhr.readyState; //boolean
-	};
-	var _resHandle = function(/*Deferred*/dfd){
-		var xhr = dfd.ioArgs.xhr;
-		if(_d._isDocumentOk(xhr)){
-			dfd.callback(dfd);
-		}else{
-			var err = new Error("Unable to load " + dfd.ioArgs.url + " status:" + xhr.status);
-			err.status = xhr.status;
-			err.responseText = xhr.responseText;
-			dfd.errback(err);
-		}
-	};
-
-	dojo._ioAddQueryToUrl = function(/*dojo.__IoCallbackArgs*/ioArgs){
-		//summary: Adds query params discovered by the io deferred construction to the URL.
-		//Only use this for operations which are fundamentally GET-type operations.
-		if(ioArgs.query.length){
-			ioArgs.url += (ioArgs.url.indexOf("?") == -1 ? "?" : "&") + ioArgs.query;
-			ioArgs.query = null;
-		}
-	};
-
-	/*=====
-	dojo.declare("dojo.__XhrArgs", dojo.__IoArgs, {
-		constructor: function(){
-			//	summary:
-			//		In addition to the properties listed for the dojo._IoArgs type,
-			//		the following properties are allowed for dojo.xhr* methods.
-			//	handleAs: String?
-			//		Acceptable values are: text (default), json, json-comment-optional,
-			//		json-comment-filtered, javascript, xml. See `dojo.contentHandlers`
-			//	sync: Boolean?
-			//		false is default. Indicates whether the request should
-			//		be a synchronous (blocking) request.
-			//	headers: Object?
-			//		Additional HTTP headers to send in the request.
-			//	failOk: Boolean?
-			//		false is default. Indicates whether a request should be
-			//		allowed to fail (and therefore no console error message in
-			//		the event of a failure)
-			this.handleAs = handleAs;
-			this.sync = sync;
-			this.headers = headers;
-			this.failOk = failOk;
-		}
-	});
-	=====*/
-
-	dojo.xhr = function(/*String*/ method, /*dojo.__XhrArgs*/ args, /*Boolean?*/ hasBody){
-		//	summary:
-		//		Sends an HTTP request with the given method.
-		//	description:
-		//		Sends an HTTP request with the given method.
-		//		See also dojo.xhrGet(), xhrPost(), xhrPut() and dojo.xhrDelete() for shortcuts
-		//		for those HTTP methods. There are also methods for "raw" PUT and POST methods
-		//		via dojo.rawXhrPut() and dojo.rawXhrPost() respectively.
-		//	method:
-		//		HTTP method to be used, such as GET, POST, PUT, DELETE.  Should be uppercase.
-		//	hasBody:
-		//		If the request has an HTTP body, then pass true for hasBody.
-
-		//Make the Deferred object for this xhr request.
-		var dfd = _d._ioSetArgs(args, _deferredCancel, _deferredOk, _deferError);
-		var ioArgs = dfd.ioArgs;
-
-		//Pass the args to _xhrObj, to allow alternate XHR calls based specific calls, like
-		//the one used for iframe proxies.
-		var xhr = ioArgs.xhr = _d._xhrObj(ioArgs.args);
-		//If XHR factory fails, cancel the deferred.
-		if(!xhr){
-			dfd.cancel();
-			return dfd;
-		}
-
-		//Allow for specifying the HTTP body completely.
-		if("postData" in args){
-			ioArgs.query = args.postData;
-		}else if("putData" in args){
-			ioArgs.query = args.putData;
-		}else if("rawBody" in args){
-			ioArgs.query = args.rawBody;
-		}else if((arguments.length > 2 && !hasBody) || "POST|PUT".indexOf(method.toUpperCase()) == -1){
-			//Check for hasBody being passed. If no hasBody,
-			//then only append query string if not a POST or PUT request.
-			_d._ioAddQueryToUrl(ioArgs);
-		}
-
-		// IE 6 is a steaming pile. It won't let you call apply() on the native function (xhr.open).
-		// workaround for IE6's apply() "issues"
-		xhr.open(method, ioArgs.url, args.sync !== true, args.user || undefined, args.password || undefined);
-		if(args.headers){
-			for(var hdr in args.headers){
-				if(hdr.toLowerCase() === "content-type" && !args.contentType){
-					args.contentType = args.headers[hdr];
-				}else if(args.headers[hdr]){
-					//Only add header if it has a value. This allows for instnace, skipping
-					//insertion of X-Requested-With by specifying empty value.
-					xhr.setRequestHeader(hdr, args.headers[hdr]);
-				}
-			}
-		}
-		// FIXME: is this appropriate for all content types?
-		xhr.setRequestHeader("Content-Type", args.contentType || _defaultContentType);
-		if(!args.headers || !("X-Requested-With" in args.headers)){
-			xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
-		}
-		// FIXME: set other headers here!
-		_d._ioNotifyStart(dfd);
-		if(dojo.config.debugAtAllCosts){
-			xhr.send(ioArgs.query);
-		}else{
-			try{
-				xhr.send(ioArgs.query);
-			}catch(e){
-				ioArgs.error = e;
-				dfd.cancel();
-			}
-		}
-		_d._ioWatch(dfd, _validCheck, _ioCheck, _resHandle);
-		xhr = null;
-		return dfd; // dojo.Deferred
-	};
-
-	dojo.xhrGet = function(/*dojo.__XhrArgs*/ args){
-		//	summary:
-		//		Sends an HTTP GET request to the server.
-		return _d.xhr("GET", args); // dojo.Deferred
-	};
-
-	dojo.rawXhrPost = dojo.xhrPost = function(/*dojo.__XhrArgs*/ args){
-		//	summary:
-		//		Sends an HTTP POST request to the server. In addtion to the properties
-		//		listed for the dojo.__XhrArgs type, the following property is allowed:
-		//	postData:
-		//		String. Send raw data in the body of the POST request.
-		return _d.xhr("POST", args, true); // dojo.Deferred
-	};
-
-	dojo.rawXhrPut = dojo.xhrPut = function(/*dojo.__XhrArgs*/ args){
-		//	summary:
-		//		Sends an HTTP PUT request to the server. In addtion to the properties
-		//		listed for the dojo.__XhrArgs type, the following property is allowed:
-		//	putData:
-		//		String. Send raw data in the body of the PUT request.
-		return _d.xhr("PUT", args, true); // dojo.Deferred
-	};
-
-	dojo.xhrDelete = function(/*dojo.__XhrArgs*/ args){
-		//	summary:
-		//		Sends an HTTP DELETE request to the server.
-		return _d.xhr("DELETE", args); //dojo.Deferred
-	};
-
-	/*
-	dojo.wrapForm = function(formNode){
-		//summary:
-		//		A replacement for FormBind, but not implemented yet.
-
-		// FIXME: need to think harder about what extensions to this we might
-		// want. What should we allow folks to do w/ this? What events to
-		// set/send?
-		throw new Error("dojo.wrapForm not yet implemented");
-	}
-	*/
-})();
-
-}
+//>>built
+define("dojo/_base/xhr",["./kernel","./sniff","require","../io-query","../dom","../dom-form","./Deferred","./json","./lang","./array","../on"],function(_1,_2,_3,_4,_5,_6,_7,_8,_9,_a,on){_2.add("native-xhr",function(){return typeof XMLHttpRequest!=="undefined";});if(1&&_3.getXhr){_1._xhrObj=_3.getXhr;}else{if(_2("native-xhr")){_1._xhrObj=function(){try{return new XMLHttpRequest();}catch(e){throw new Error("XMLHTTP not available: "+e);}};}else{for(var _b=["Msxml2.XMLHTTP","Microsoft.XMLHTTP","Msxml2.XMLHTTP.4.0"],_c,i=0;i<3;){try{_c=_b[i++];if(new ActiveXObject(_c)){break;}}catch(e){}}_1._xhrObj=function(){return new ActiveXObject(_c);};}}var _d=_1.config;_1.objectToQuery=_4.objectToQuery;_1.queryToObject=_4.queryToObject;_1.fieldToObject=_6.fieldToObject;_1.formToObject=_6.toObject;_1.formToQuery=_6.toQuery;_1.formToJson=_6.toJson;_1._blockAsync=false;var _e=_1._contentHandlers=_1.contentHandlers={"text":function(_f){return _f.responseText;},"json":function(xhr){return _8.fromJson(xhr.responseText||null);},"json-comment-filtered":function(xhr){if(!_1.config.useCommentedJson){console.warn("Consider using the standard mimetype:application/json."+" json-commenting can introduce security issues. To"+" decrease the chances of hijacking, use the standard the 'json' handler and"+" prefix your json with: {}&&\n"+"Use djConfig.useCommentedJson=true to turn off this message.");}var _10=xhr.responseText;var _11=_10.indexOf("/*");var _12=_10.lastIndexOf("*/");if(_11==-1||_12==-1){throw new Error("JSON was not comment filtered");}return _8.fromJson(_10.substring(_11+2,_12));},"javascript":function(xhr){return _1.eval(xhr.responseText);},"xml":function(xhr){var _13=xhr.responseXML;if(_2("ie")){if((!_13||!_13.documentElement)){var ms=function(n){return "MSXML"+n+".DOMDocument";};var dp=["Microsoft.XMLDOM",ms(6),ms(4),ms(3),ms(2)];_a.some(dp,function(p){try{var dom=new ActiveXObject(p);dom.async=false;dom.loadXML(xhr.responseText);_13=dom;}catch(e){return false;}return true;});}}return _13;},"json-comment-optional":function(xhr){if(xhr.responseText&&/^[^{\[]*\/\*/.test(xhr.responseText)){return _e["json-comment-filtered"](xhr);}else{return _e["json"](xhr);}}};_1._ioSetArgs=function(_14,_15,_16,_17){var _18={args:_14,url:_14.url};var _19=null;if(_14.form){var _1a=_5.byId(_14.form);var _1b=_1a.getAttributeNode("action");_18.url=_18.url||(_1b?_1b.value:null);_19=_6.toObject(_1a);}var _1c=[{}];if(_19){_1c.push(_19);}if(_14.content){_1c.push(_14.content);}if(_14.preventCache){_1c.push({"dojo.preventCache":new Date().valueOf()});}_18.query=_4.objectToQuery(_9.mixin.apply(null,_1c));_18.handleAs=_14.handleAs||"text";var d=new _7(_15);d.addCallbacks(_16,function(_1d){return _17(_1d,d);});var ld=_14.load;if(ld&&_9.isFunction(ld)){d.addCallback(function(_1e){return ld.call(_14,_1e,_18);});}var err=_14.error;if(err&&_9.isFunction(err)){d.addErrback(function(_1f){return err.call(_14,_1f,_18);});}var _20=_14.handle;if(_20&&_9.isFunction(_20)){d.addBoth(function(_21){return _20.call(_14,_21,_18);});}if(_d.ioPublish&&_1.publish&&_18.args.ioPublish!==false){d.addCallbacks(function(res){_1.publish("/dojo/io/load",[d,res]);return res;},function(res){_1.publish("/dojo/io/error",[d,res]);return res;});d.addBoth(function(res){_1.publish("/dojo/io/done",[d,res]);return res;});}d.ioArgs=_18;return d;};var _22=function(dfd){dfd.canceled=true;var xhr=dfd.ioArgs.xhr;var _23=typeof xhr.abort;if(_23=="function"||_23=="object"||_23=="unknown"){xhr.abort();}var err=dfd.ioArgs.error;if(!err){err=new Error("xhr cancelled");err.dojoType="cancel";}return err;};var _24=function(dfd){var ret=_e[dfd.ioArgs.handleAs](dfd.ioArgs.xhr);return ret===undefined?null:ret;};var _25=function(_26,dfd){if(!dfd.ioArgs.args.failOk){console.error(_26);}return _26;};var _27=null;var _28=[];var _29=0;var _2a=function(dfd){if(_29<=0){_29=0;if(_d.ioPublish&&_1.publish&&(!dfd||dfd&&dfd.ioArgs.args.ioPublish!==false)){_1.publish("/dojo/io/stop");}}};var _2b=function(){var now=(new Date()).getTime();if(!_1._blockAsync){for(var i=0,tif;i<_28.length&&(tif=_28[i]);i++){var dfd=tif.dfd;var _2c=function(){if(!dfd||dfd.canceled||!tif.validCheck(dfd)){_28.splice(i--,1);_29-=1;}else{if(tif.ioCheck(dfd)){_28.splice(i--,1);tif.resHandle(dfd);_29-=1;}else{if(dfd.startTime){if(dfd.startTime+(dfd.ioArgs.args.timeout||0)<now){_28.splice(i--,1);var err=new Error("timeout exceeded");err.dojoType="timeout";dfd.errback(err);dfd.cancel();_29-=1;}}}}};if(_1.config.debugAtAllCosts){_2c.call(this);}else{try{_2c.call(this);}catch(e){dfd.errback(e);}}}}_2a(dfd);if(!_28.length){clearInterval(_27);_27=null;}};_1._ioCancelAll=function(){try{_a.forEach(_28,function(i){try{i.dfd.cancel();}catch(e){}});}catch(e){}};if(_2("ie")){on(window,"unload",_1._ioCancelAll);}_1._ioNotifyStart=function(dfd){if(_d.ioPublish&&_1.publish&&dfd.ioArgs.args.ioPublish!==false){if(!_29){_1.publish("/dojo/io/start");}_29+=1;_1.publish("/dojo/io/send",[dfd]);}};_1._ioWatch=function(dfd,_2d,_2e,_2f){var _30=dfd.ioArgs.args;if(_30.timeout){dfd.startTime=(new Date()).getTime();}_28.push({dfd:dfd,validCheck:_2d,ioCheck:_2e,resHandle:_2f});if(!_27){_27=setInterval(_2b,50);}if(_30.sync){_2b();}};var _31="application/x-www-form-urlencoded";var _32=function(dfd){return dfd.ioArgs.xhr.readyState;};var _33=function(dfd){return 4==dfd.ioArgs.xhr.readyState;};var _34=function(dfd){var xhr=dfd.ioArgs.xhr;if(_1._isDocumentOk(xhr)){dfd.callback(dfd);}else{var err=new Error("Unable to load "+dfd.ioArgs.url+" status:"+xhr.status);err.status=xhr.status;err.responseText=xhr.responseText;err.xhr=xhr;dfd.errback(err);}};_1._ioAddQueryToUrl=function(_35){if(_35.query.length){_35.url+=(_35.url.indexOf("?")==-1?"?":"&")+_35.query;_35.query=null;}};_1.xhr=function(_36,_37,_38){var dfd=_1._ioSetArgs(_37,_22,_24,_25);var _39=dfd.ioArgs;var xhr=_39.xhr=_1._xhrObj(_39.args);if(!xhr){dfd.cancel();return dfd;}if("postData" in _37){_39.query=_37.postData;}else{if("putData" in _37){_39.query=_37.putData;}else{if("rawBody" in _37){_39.query=_37.rawBody;}else{if((arguments.length>2&&!_38)||"POST|PUT".indexOf(_36.toUpperCase())==-1){_1._ioAddQueryToUrl(_39);}}}}xhr.open(_36,_39.url,_37.sync!==true,_37.user||undefined,_37.password||undefined);if(_37.headers){for(var hdr in _37.headers){if(hdr.toLowerCase()==="content-type"&&!_37.contentType){_37.contentType=_37.headers[hdr];}else{if(_37.headers[hdr]){xhr.setRequestHeader(hdr,_37.headers[hdr]);}}}}if(_37.contentType!==false){xhr.setRequestHeader("Content-Type",_37.contentType||_31);}if(!_37.headers||!("X-Requested-With" in _37.headers)){xhr.setRequestHeader("X-Requested-With","XMLHttpRequest");}_1._ioNotifyStart(dfd);if(_1.config.debugAtAllCosts){xhr.send(_39.query);}else{try{xhr.send(_39.query);}catch(e){_39.error=e;dfd.cancel();}}_1._ioWatch(dfd,_32,_33,_34);xhr=null;return dfd;};_1.xhrGet=function(_3a){return _1.xhr("GET",_3a);};_1.rawXhrPost=_1.xhrPost=function(_3b){return _1.xhr("POST",_3b,true);};_1.rawXhrPut=_1.xhrPut=function(_3c){return _1.xhr("PUT",_3c,true);};_1.xhrDelete=function(_3d){return _1.xhr("DELETE",_3d);};_1._isDocumentOk=function(_3e){var _3f=_3e.status||0;_3f=(_3f>=200&&_3f<300)||_3f==304||_3f==1223||!_3f;return _3f;};_1._getText=function(url){var _40;_1.xhrGet({url:url,sync:true,load:function(_41){_40=_41;}});return _40;};_9.mixin(_1.xhr,{_xhrObj:_1._xhrObj,fieldToObject:_6.fieldToObject,formToObject:_6.toObject,objectToQuery:_4.objectToQuery,formToQuery:_6.toQuery,formToJson:_6.toJson,queryToObject:_4.queryToObject,contentHandlers:_e,_ioSetArgs:_1._ioSetArgs,_ioCancelAll:_1._ioCancelAll,_ioNotifyStart:_1._ioNotifyStart,_ioWatch:_1._ioWatch,_ioAddQueryToUrl:_1._ioAddQueryToUrl,_isDocumentOk:_1._isDocumentOk,_getText:_1._getText,get:_1.xhrGet,post:_1.xhrPost,put:_1.xhrPut,del:_1.xhrDelete});return _1.xhr;});
\ No newline at end of file
diff --git a/lib/dojo/_base/xhr.js.uncompressed.js b/lib/dojo/_base/xhr.js.uncompressed.js
new file mode 100644
index 000000000..94f5c78b1
--- /dev/null
+++ b/lib/dojo/_base/xhr.js.uncompressed.js
@@ -0,0 +1,830 @@
+define("dojo/_base/xhr", [
+	"./kernel", "./sniff", "require", "../io-query", "../dom", "../dom-form", "./Deferred", "./json", "./lang", "./array", "../on"
+], function(dojo, has, require, ioq, dom, domForm, deferred, json, lang, array, on){
+	//	module:
+	//		dojo/_base.xhr
+	// summary:
+	//		This modules defines the dojo.xhr* API.
+
+	has.add("native-xhr", function() {
+		// if true, the environment has a native XHR implementation
+		return typeof XMLHttpRequest !== 'undefined';
+	});
+
+	if(1 && require.getXhr){
+		dojo._xhrObj = require.getXhr;
+	}else if (has("native-xhr")){
+		dojo._xhrObj = function(){
+			// summary:
+			//		does the work of portably generating a new XMLHTTPRequest object.
+			try{
+				return new XMLHttpRequest();
+			}catch(e){
+				throw new Error("XMLHTTP not available: "+e);
+			}
+		};
+	}else{
+		// PROGIDs are in order of decreasing likelihood; this will change in time.
+		for(var XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'], progid, i = 0; i < 3;){
+			try{
+				progid = XMLHTTP_PROGIDS[i++];
+				if (new ActiveXObject(progid)) {
+					// this progid works; therefore, use it from now on
+					break;
+				}
+			}catch(e){
+				// squelch; we're just trying to find a good ActiveX PROGID
+				// if they all fail, then progid ends up as the last attempt and that will signal the error
+				// the first time the client actually tries to exec an xhr
+			}
+		}
+		dojo._xhrObj= function() {
+			return new ActiveXObject(progid);
+		};
+	}
+
+	var cfg = dojo.config;
+
+	// mix in io-query and dom-form
+	dojo.objectToQuery = ioq.objectToQuery;
+	dojo.queryToObject = ioq.queryToObject;
+	dojo.fieldToObject = domForm.fieldToObject;
+	dojo.formToObject = domForm.toObject;
+	dojo.formToQuery = domForm.toQuery;
+	dojo.formToJson = domForm.toJson;
+
+	// need to block async callbacks from snatching this thread as the result
+	// of an async callback might call another sync XHR, this hangs khtml forever
+	// must checked by watchInFlight()
+
+	dojo._blockAsync = false;
+
+	// MOW: remove dojo._contentHandlers alias in 2.0
+	var handlers = dojo._contentHandlers = dojo.contentHandlers = {
+		// summary:
+		//		A map of availble XHR transport handle types. Name matches the
+		//		`handleAs` attribute passed to XHR calls.
+		//
+		// description:
+		//		A map of availble XHR transport handle types. Name matches the
+		//		`handleAs` attribute passed to XHR calls. Each contentHandler is
+		//		called, passing the xhr object for manipulation. The return value
+		//		from the contentHandler will be passed to the `load` or `handle`
+		//		functions defined in the original xhr call.
+		//
+		// example:
+		//		Creating a custom content-handler:
+		//	|	dojo.contentHandlers.makeCaps = function(xhr){
+		//	|		return xhr.responseText.toUpperCase();
+		//	|	}
+		//	|	// and later:
+		//	|	dojo.xhrGet({
+		//	|		url:"foo.txt",
+		//	|		handleAs:"makeCaps",
+		//	|		load: function(data){ /* data is a toUpper version of foo.txt */ }
+		//	|	});
+
+		"text": function(xhr){
+			// summary: A contentHandler which simply returns the plaintext response data
+			return xhr.responseText;
+		},
+		"json": function(xhr){
+			// summary: A contentHandler which returns a JavaScript object created from the response data
+			return json.fromJson(xhr.responseText || null);
+		},
+		"json-comment-filtered": function(xhr){
+			// summary: A contentHandler which expects comment-filtered JSON.
+			// description:
+			//		A contentHandler which expects comment-filtered JSON.
+			//		the json-comment-filtered option was implemented to prevent
+			//		"JavaScript Hijacking", but it is less secure than standard JSON. Use
+			//		standard JSON instead. JSON prefixing can be used to subvert hijacking.
+			//
+			//		Will throw a notice suggesting to use application/json mimetype, as
+			//		json-commenting can introduce security issues. To decrease the chances of hijacking,
+			//		use the standard `json` contentHandler, and prefix your "JSON" with: {}&&
+			//
+			//		use djConfig.useCommentedJson = true to turn off the notice
+			if(!dojo.config.useCommentedJson){
+				console.warn("Consider using the standard mimetype:application/json."
+					+ " json-commenting can introduce security issues. To"
+					+ " decrease the chances of hijacking, use the standard the 'json' handler and"
+					+ " prefix your json with: {}&&\n"
+					+ "Use djConfig.useCommentedJson=true to turn off this message.");
+			}
+
+			var value = xhr.responseText;
+			var cStartIdx = value.indexOf("\/*");
+			var cEndIdx = value.lastIndexOf("*\/");
+			if(cStartIdx == -1 || cEndIdx == -1){
+				throw new Error("JSON was not comment filtered");
+			}
+			return json.fromJson(value.substring(cStartIdx+2, cEndIdx));
+		},
+		"javascript": function(xhr){
+			// summary: A contentHandler which evaluates the response data, expecting it to be valid JavaScript
+
+			// FIXME: try Moz and IE specific eval variants?
+			return dojo.eval(xhr.responseText);
+		},
+		"xml": function(xhr){
+			// summary: A contentHandler returning an XML Document parsed from the response data
+			var result = xhr.responseXML;
+
+			if(has("ie")){
+				if((!result || !result.documentElement)){
+					//WARNING: this branch used by the xml handling in dojo.io.iframe,
+					//so be sure to test dojo.io.iframe if making changes below.
+					var ms = function(n){ return "MSXML" + n + ".DOMDocument"; };
+					var dp = ["Microsoft.XMLDOM", ms(6), ms(4), ms(3), ms(2)];
+					array.some(dp, function(p){
+						try{
+							var dom = new ActiveXObject(p);
+							dom.async = false;
+							dom.loadXML(xhr.responseText);
+							result = dom;
+						}catch(e){ return false; }
+						return true;
+					});
+				}
+		 }
+			return result; // DOMDocument
+		},
+		"json-comment-optional": function(xhr){
+			// summary: A contentHandler which checks the presence of comment-filtered JSON and
+			//		alternates between the `json` and `json-comment-filtered` contentHandlers.
+			if(xhr.responseText && /^[^{\[]*\/\*/.test(xhr.responseText)){
+				return handlers["json-comment-filtered"](xhr);
+			}else{
+				return handlers["json"](xhr);
+			}
+		}
+	};
+
+	/*=====
+	dojo.__IoArgs = function(){
+		//	url: String
+		//		URL to server endpoint.
+		//	content: Object?
+		//		Contains properties with string values. These
+		//		properties will be serialized as name1=value2 and
+		//		passed in the request.
+		//	timeout: Integer?
+		//		Milliseconds to wait for the response. If this time
+		//		passes, the then error callbacks are called.
+		//	form: DOMNode?
+		//		DOM node for a form. Used to extract the form values
+		//		and send to the server.
+		//	preventCache: Boolean?
+		//		Default is false. If true, then a
+		//		"dojo.preventCache" parameter is sent in the request
+		//		with a value that changes with each request
+		//		(timestamp). Useful only with GET-type requests.
+		//	handleAs: String?
+		//		Acceptable values depend on the type of IO
+		//		transport (see specific IO calls for more information).
+		//	rawBody: String?
+		//		Sets the raw body for an HTTP request. If this is used, then the content
+		//		property is ignored. This is mostly useful for HTTP methods that have
+		//		a body to their requests, like PUT or POST. This property can be used instead
+		//		of postData and putData for dojo.rawXhrPost and dojo.rawXhrPut respectively.
+		//	ioPublish: Boolean?
+		//		Set this explicitly to false to prevent publishing of topics related to
+		//		IO operations. Otherwise, if djConfig.ioPublish is set to true, topics
+		//		will be published via dojo.publish for different phases of an IO operation.
+		//		See dojo.__IoPublish for a list of topics that are published.
+		//	load: Function?
+		//		This function will be
+		//		called on a successful HTTP response code.
+		//	error: Function?
+		//		This function will
+		//		be called when the request fails due to a network or server error, the url
+		//		is invalid, etc. It will also be called if the load or handle callback throws an
+		//		exception, unless djConfig.debugAtAllCosts is true.	 This allows deployed applications
+		//		to continue to run even when a logic error happens in the callback, while making
+		//		it easier to troubleshoot while in debug mode.
+		//	handle: Function?
+		//		This function will
+		//		be called at the end of every request, whether or not an error occurs.
+		this.url = url;
+		this.content = content;
+		this.timeout = timeout;
+		this.form = form;
+		this.preventCache = preventCache;
+		this.handleAs = handleAs;
+		this.ioPublish = ioPublish;
+		this.load = function(response, ioArgs){
+			// ioArgs: dojo.__IoCallbackArgs
+			//		Provides additional information about the request.
+			// response: Object
+			//		The response in the format as defined with handleAs.
+		}
+		this.error = function(response, ioArgs){
+			// ioArgs: dojo.__IoCallbackArgs
+			//		Provides additional information about the request.
+			// response: Object
+			//		The response in the format as defined with handleAs.
+		}
+		this.handle = function(loadOrError, response, ioArgs){
+			// loadOrError: String
+			//		Provides a string that tells you whether this function
+			//		was called because of success (load) or failure (error).
+			// response: Object
+			//		The response in the format as defined with handleAs.
+			// ioArgs: dojo.__IoCallbackArgs
+			//		Provides additional information about the request.
+		}
+	}
+	=====*/
+
+	/*=====
+	dojo.__IoCallbackArgs = function(args, xhr, url, query, handleAs, id, canDelete, json){
+		//	args: Object
+		//		the original object argument to the IO call.
+		//	xhr: XMLHttpRequest
+		//		For XMLHttpRequest calls only, the
+		//		XMLHttpRequest object that was used for the
+		//		request.
+		//	url: String
+		//		The final URL used for the call. Many times it
+		//		will be different than the original args.url
+		//		value.
+		//	query: String
+		//		For non-GET requests, the
+		//		name1=value1&name2=value2 parameters sent up in
+		//		the request.
+		//	handleAs: String
+		//		The final indicator on how the response will be
+		//		handled.
+		//	id: String
+		//		For dojo.io.script calls only, the internal
+		//		script ID used for the request.
+		//	canDelete: Boolean
+		//		For dojo.io.script calls only, indicates
+		//		whether the script tag that represents the
+		//		request can be deleted after callbacks have
+		//		been called. Used internally to know when
+		//		cleanup can happen on JSONP-type requests.
+		//	json: Object
+		//		For dojo.io.script calls only: holds the JSON
+		//		response for JSONP-type requests. Used
+		//		internally to hold on to the JSON responses.
+		//		You should not need to access it directly --
+		//		the same object should be passed to the success
+		//		callbacks directly.
+		this.args = args;
+		this.xhr = xhr;
+		this.url = url;
+		this.query = query;
+		this.handleAs = handleAs;
+		this.id = id;
+		this.canDelete = canDelete;
+		this.json = json;
+	}
+	=====*/
+
+
+	/*=====
+	dojo.__IoPublish = function(){
+		//	summary:
+		//		This is a list of IO topics that can be published
+		//		if djConfig.ioPublish is set to true. IO topics can be
+		//		published for any Input/Output, network operation. So,
+		//		dojo.xhr, dojo.io.script and dojo.io.iframe can all
+		//		trigger these topics to be published.
+		//	start: String
+		//		"/dojo/io/start" is sent when there are no outstanding IO
+		//		requests, and a new IO request is started. No arguments
+		//		are passed with this topic.
+		//	send: String
+		//		"/dojo/io/send" is sent whenever a new IO request is started.
+		//		It passes the dojo.Deferred for the request with the topic.
+		//	load: String
+		//		"/dojo/io/load" is sent whenever an IO request has loaded
+		//		successfully. It passes the response and the dojo.Deferred
+		//		for the request with the topic.
+		//	error: String
+		//		"/dojo/io/error" is sent whenever an IO request has errored.
+		//		It passes the error and the dojo.Deferred
+		//		for the request with the topic.
+		//	done: String
+		//		"/dojo/io/done" is sent whenever an IO request has completed,
+		//		either by loading or by erroring. It passes the error and
+		//		the dojo.Deferred for the request with the topic.
+		//	stop: String
+		//		"/dojo/io/stop" is sent when all outstanding IO requests have
+		//		finished. No arguments are passed with this topic.
+		this.start = "/dojo/io/start";
+		this.send = "/dojo/io/send";
+		this.load = "/dojo/io/load";
+		this.error = "/dojo/io/error";
+		this.done = "/dojo/io/done";
+		this.stop = "/dojo/io/stop";
+	}
+	=====*/
+
+
+	dojo._ioSetArgs = function(/*dojo.__IoArgs*/args,
+			/*Function*/canceller,
+			/*Function*/okHandler,
+			/*Function*/errHandler){
+		//	summary:
+		//		sets up the Deferred and ioArgs property on the Deferred so it
+		//		can be used in an io call.
+		//	args:
+		//		The args object passed into the public io call. Recognized properties on
+		//		the args object are:
+		//	canceller:
+		//		The canceller function used for the Deferred object. The function
+		//		will receive one argument, the Deferred object that is related to the
+		//		canceller.
+		//	okHandler:
+		//		The first OK callback to be registered with Deferred. It has the opportunity
+		//		to transform the OK response. It will receive one argument -- the Deferred
+		//		object returned from this function.
+		//	errHandler:
+		//		The first error callback to be registered with Deferred. It has the opportunity
+		//		to do cleanup on an error. It will receive two arguments: error (the
+		//		Error object) and dfd, the Deferred object returned from this function.
+
+		var ioArgs = {args: args, url: args.url};
+
+		//Get values from form if requestd.
+		var formObject = null;
+		if(args.form){
+			var form = dom.byId(args.form);
+			//IE requires going through getAttributeNode instead of just getAttribute in some form cases,
+			//so use it for all. See #2844
+			var actnNode = form.getAttributeNode("action");
+			ioArgs.url = ioArgs.url || (actnNode ? actnNode.value : null);
+			formObject = domForm.toObject(form);
+		}
+
+		// set up the query params
+		var miArgs = [{}];
+
+		if(formObject){
+			// potentially over-ride url-provided params w/ form values
+			miArgs.push(formObject);
+		}
+		if(args.content){
+			// stuff in content over-rides what's set by form
+			miArgs.push(args.content);
+		}
+		if(args.preventCache){
+			miArgs.push({"dojo.preventCache": new Date().valueOf()});
+		}
+		ioArgs.query = ioq.objectToQuery(lang.mixin.apply(null, miArgs));
+
+		// .. and the real work of getting the deferred in order, etc.
+		ioArgs.handleAs = args.handleAs || "text";
+		var d = new deferred(canceller);
+		d.addCallbacks(okHandler, function(error){
+			return errHandler(error, d);
+		});
+
+		//Support specifying load, error and handle callback functions from the args.
+		//For those callbacks, the "this" object will be the args object.
+		//The callbacks will get the deferred result value as the
+		//first argument and the ioArgs object as the second argument.
+		var ld = args.load;
+		if(ld && lang.isFunction(ld)){
+			d.addCallback(function(value){
+				return ld.call(args, value, ioArgs);
+			});
+		}
+		var err = args.error;
+		if(err && lang.isFunction(err)){
+			d.addErrback(function(value){
+				return err.call(args, value, ioArgs);
+			});
+		}
+		var handle = args.handle;
+		if(handle && lang.isFunction(handle)){
+			d.addBoth(function(value){
+				return handle.call(args, value, ioArgs);
+			});
+		}
+
+		//Plug in topic publishing, if dojo.publish is loaded.
+		if(cfg.ioPublish && dojo.publish && ioArgs.args.ioPublish !== false){
+			d.addCallbacks(
+				function(res){
+					dojo.publish("/dojo/io/load", [d, res]);
+					return res;
+				},
+				function(res){
+					dojo.publish("/dojo/io/error", [d, res]);
+					return res;
+				}
+			);
+			d.addBoth(function(res){
+				dojo.publish("/dojo/io/done", [d, res]);
+				return res;
+			});
+		}
+
+		d.ioArgs = ioArgs;
+
+		// FIXME: need to wire up the xhr object's abort method to something
+		// analagous in the Deferred
+		return d;
+	};
+
+	var _deferredCancel = function(/*Deferred*/dfd){
+		// summary: canceller function for dojo._ioSetArgs call.
+
+		dfd.canceled = true;
+		var xhr = dfd.ioArgs.xhr;
+		var _at = typeof xhr.abort;
+		if(_at == "function" || _at == "object" || _at == "unknown"){
+			xhr.abort();
+		}
+		var err = dfd.ioArgs.error;
+		if(!err){
+			err = new Error("xhr cancelled");
+			err.dojoType="cancel";
+		}
+		return err;
+	};
+	var _deferredOk = function(/*Deferred*/dfd){
+		// summary: okHandler function for dojo._ioSetArgs call.
+
+		var ret = handlers[dfd.ioArgs.handleAs](dfd.ioArgs.xhr);
+		return ret === undefined ? null : ret;
+	};
+	var _deferError = function(/*Error*/error, /*Deferred*/dfd){
+		// summary: errHandler function for dojo._ioSetArgs call.
+
+		if(!dfd.ioArgs.args.failOk){
+			console.error(error);
+		}
+		return error;
+	};
+
+	// avoid setting a timer per request. It degrades performance on IE
+	// something fierece if we don't use unified loops.
+	var _inFlightIntvl = null;
+	var _inFlight = [];
+
+
+	//Use a separate count for knowing if we are starting/stopping io calls.
+	//Cannot use _inFlight.length since it can change at a different time than
+	//when we want to do this kind of test. We only want to decrement the count
+	//after a callback/errback has finished, since the callback/errback should be
+	//considered as part of finishing a request.
+	var _pubCount = 0;
+	var _checkPubCount = function(dfd){
+		if(_pubCount <= 0){
+			_pubCount = 0;
+			if(cfg.ioPublish && dojo.publish && (!dfd || dfd && dfd.ioArgs.args.ioPublish !== false)){
+				dojo.publish("/dojo/io/stop");
+			}
+		}
+	};
+
+	var _watchInFlight = function(){
+		//summary:
+		//		internal method that checks each inflight XMLHttpRequest to see
+		//		if it has completed or if the timeout situation applies.
+
+		var now = (new Date()).getTime();
+		// make sure sync calls stay thread safe, if this callback is called
+		// during a sync call and this results in another sync call before the
+		// first sync call ends the browser hangs
+		if(!dojo._blockAsync){
+			// we need manual loop because we often modify _inFlight (and therefore 'i') while iterating
+			// note: the second clause is an assigment on purpose, lint may complain
+			for(var i = 0, tif; i < _inFlight.length && (tif = _inFlight[i]); i++){
+				var dfd = tif.dfd;
+				var func = function(){
+					if(!dfd || dfd.canceled || !tif.validCheck(dfd)){
+						_inFlight.splice(i--, 1);
+						_pubCount -= 1;
+					}else if(tif.ioCheck(dfd)){
+						_inFlight.splice(i--, 1);
+						tif.resHandle(dfd);
+						_pubCount -= 1;
+					}else if(dfd.startTime){
+						//did we timeout?
+						if(dfd.startTime + (dfd.ioArgs.args.timeout || 0) < now){
+							_inFlight.splice(i--, 1);
+							var err = new Error("timeout exceeded");
+							err.dojoType = "timeout";
+							dfd.errback(err);
+							//Cancel the request so the io module can do appropriate cleanup.
+							dfd.cancel();
+							_pubCount -= 1;
+						}
+					}
+				};
+				if(dojo.config.debugAtAllCosts){
+					func.call(this);
+				}else{
+					try{
+						func.call(this);
+					}catch(e){
+						dfd.errback(e);
+					}
+				}
+			}
+		}
+
+		_checkPubCount(dfd);
+
+		if(!_inFlight.length){
+			clearInterval(_inFlightIntvl);
+			_inFlightIntvl = null;
+		}
+	};
+
+	dojo._ioCancelAll = function(){
+		//summary: Cancels all pending IO requests, regardless of IO type
+		//(xhr, script, iframe).
+		try{
+			array.forEach(_inFlight, function(i){
+				try{
+					i.dfd.cancel();
+				}catch(e){/*squelch*/}
+			});
+		}catch(e){/*squelch*/}
+	};
+
+	//Automatically call cancel all io calls on unload
+	//in IE for trac issue #2357.
+	if(has("ie")){
+		on(window, "unload", dojo._ioCancelAll);
+	}
+
+	dojo._ioNotifyStart = function(/*Deferred*/dfd){
+		// summary:
+		//		If dojo.publish is available, publish topics
+		//		about the start of a request queue and/or the
+		//		the beginning of request.
+		// description:
+		//		Used by IO transports. An IO transport should
+		//		call this method before making the network connection.
+		if(cfg.ioPublish && dojo.publish && dfd.ioArgs.args.ioPublish !== false){
+			if(!_pubCount){
+				dojo.publish("/dojo/io/start");
+			}
+			_pubCount += 1;
+			dojo.publish("/dojo/io/send", [dfd]);
+		}
+	};
+
+	dojo._ioWatch = function(dfd, validCheck, ioCheck, resHandle){
+		// summary:
+		//		Watches the io request represented by dfd to see if it completes.
+		// dfd: Deferred
+		//		The Deferred object to watch.
+		// validCheck: Function
+		//		Function used to check if the IO request is still valid. Gets the dfd
+		//		object as its only argument.
+		// ioCheck: Function
+		//		Function used to check if basic IO call worked. Gets the dfd
+		//		object as its only argument.
+		// resHandle: Function
+		//		Function used to process response. Gets the dfd
+		//		object as its only argument.
+		var args = dfd.ioArgs.args;
+		if(args.timeout){
+			dfd.startTime = (new Date()).getTime();
+		}
+
+		_inFlight.push({dfd: dfd, validCheck: validCheck, ioCheck: ioCheck, resHandle: resHandle});
+		if(!_inFlightIntvl){
+			_inFlightIntvl = setInterval(_watchInFlight, 50);
+		}
+		// handle sync requests
+		//A weakness: async calls in flight
+		//could have their handlers called as part of the
+		//_watchInFlight call, before the sync's callbacks
+		// are called.
+		if(args.sync){
+			_watchInFlight();
+		}
+	};
+
+	var _defaultContentType = "application/x-www-form-urlencoded";
+
+	var _validCheck = function(/*Deferred*/dfd){
+		return dfd.ioArgs.xhr.readyState; //boolean
+	};
+	var _ioCheck = function(/*Deferred*/dfd){
+		return 4 == dfd.ioArgs.xhr.readyState; //boolean
+	};
+	var _resHandle = function(/*Deferred*/dfd){
+		var xhr = dfd.ioArgs.xhr;
+		if(dojo._isDocumentOk(xhr)){
+			dfd.callback(dfd);
+		}else{
+			var err = new Error("Unable to load " + dfd.ioArgs.url + " status:" + xhr.status);
+			err.status = xhr.status;
+			err.responseText = xhr.responseText;
+			err.xhr = xhr;
+			dfd.errback(err);
+		}
+	};
+
+	dojo._ioAddQueryToUrl = function(/*dojo.__IoCallbackArgs*/ioArgs){
+		//summary: Adds query params discovered by the io deferred construction to the URL.
+		//Only use this for operations which are fundamentally GET-type operations.
+		if(ioArgs.query.length){
+			ioArgs.url += (ioArgs.url.indexOf("?") == -1 ? "?" : "&") + ioArgs.query;
+			ioArgs.query = null;
+		}
+	};
+
+	/*=====
+	dojo.declare("dojo.__XhrArgs", dojo.__IoArgs, {
+		constructor: function(){
+			//	summary:
+			//		In addition to the properties listed for the dojo._IoArgs type,
+			//		the following properties are allowed for dojo.xhr* methods.
+			//	handleAs: String?
+			//		Acceptable values are: text (default), json, json-comment-optional,
+			//		json-comment-filtered, javascript, xml. See `dojo.contentHandlers`
+			//	sync: Boolean?
+			//		false is default. Indicates whether the request should
+			//		be a synchronous (blocking) request.
+			//	headers: Object?
+			//		Additional HTTP headers to send in the request.
+			//	failOk: Boolean?
+			//		false is default. Indicates whether a request should be
+			//		allowed to fail (and therefore no console error message in
+			//		the event of a failure)
+			//	contentType: String|Boolean
+			//		"application/x-www-form-urlencoded" is default. Set to false to
+			//		prevent a Content-Type header from being sent, or to a string
+			//		to send a different Content-Type.
+			this.handleAs = handleAs;
+			this.sync = sync;
+			this.headers = headers;
+			this.failOk = failOk;
+		}
+	});
+	=====*/
+
+	dojo.xhr = function(/*String*/ method, /*dojo.__XhrArgs*/ args, /*Boolean?*/ hasBody){
+		//	summary:
+		//		Sends an HTTP request with the given method.
+		//	description:
+		//		Sends an HTTP request with the given method.
+		//		See also dojo.xhrGet(), xhrPost(), xhrPut() and dojo.xhrDelete() for shortcuts
+		//		for those HTTP methods. There are also methods for "raw" PUT and POST methods
+		//		via dojo.rawXhrPut() and dojo.rawXhrPost() respectively.
+		//	method:
+		//		HTTP method to be used, such as GET, POST, PUT, DELETE. Should be uppercase.
+		//	hasBody:
+		//		If the request has an HTTP body, then pass true for hasBody.
+
+		//Make the Deferred object for this xhr request.
+		var dfd = dojo._ioSetArgs(args, _deferredCancel, _deferredOk, _deferError);
+		var ioArgs = dfd.ioArgs;
+
+		//Pass the args to _xhrObj, to allow alternate XHR calls based specific calls, like
+		//the one used for iframe proxies.
+		var xhr = ioArgs.xhr = dojo._xhrObj(ioArgs.args);
+		//If XHR factory fails, cancel the deferred.
+		if(!xhr){
+			dfd.cancel();
+			return dfd;
+		}
+
+		//Allow for specifying the HTTP body completely.
+		if("postData" in args){
+			ioArgs.query = args.postData;
+		}else if("putData" in args){
+			ioArgs.query = args.putData;
+		}else if("rawBody" in args){
+			ioArgs.query = args.rawBody;
+		}else if((arguments.length > 2 && !hasBody) || "POST|PUT".indexOf(method.toUpperCase()) == -1){
+			//Check for hasBody being passed. If no hasBody,
+			//then only append query string if not a POST or PUT request.
+			dojo._ioAddQueryToUrl(ioArgs);
+		}
+
+		// IE 6 is a steaming pile. It won't let you call apply() on the native function (xhr.open).
+		// workaround for IE6's apply() "issues"
+		xhr.open(method, ioArgs.url, args.sync !== true, args.user || undefined, args.password || undefined);
+		if(args.headers){
+			for(var hdr in args.headers){
+				if(hdr.toLowerCase() === "content-type" && !args.contentType){
+					args.contentType = args.headers[hdr];
+				}else if(args.headers[hdr]){
+					//Only add header if it has a value. This allows for instnace, skipping
+					//insertion of X-Requested-With by specifying empty value.
+					xhr.setRequestHeader(hdr, args.headers[hdr]);
+				}
+			}
+		}
+		// FIXME: is this appropriate for all content types?
+		if(args.contentType !== false){
+			xhr.setRequestHeader("Content-Type", args.contentType || _defaultContentType);
+		}
+		if(!args.headers || !("X-Requested-With" in args.headers)){
+			xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+		}
+		// FIXME: set other headers here!
+		dojo._ioNotifyStart(dfd);
+		if(dojo.config.debugAtAllCosts){
+			xhr.send(ioArgs.query);
+		}else{
+			try{
+				xhr.send(ioArgs.query);
+			}catch(e){
+				ioArgs.error = e;
+				dfd.cancel();
+			}
+		}
+		dojo._ioWatch(dfd, _validCheck, _ioCheck, _resHandle);
+		xhr = null;
+		return dfd; // dojo.Deferred
+	};
+
+	dojo.xhrGet = function(/*dojo.__XhrArgs*/ args){
+		//	summary:
+		//		Sends an HTTP GET request to the server.
+		return dojo.xhr("GET", args); // dojo.Deferred
+	};
+
+	dojo.rawXhrPost = dojo.xhrPost = function(/*dojo.__XhrArgs*/ args){
+		//	summary:
+		//		Sends an HTTP POST request to the server. In addtion to the properties
+		//		listed for the dojo.__XhrArgs type, the following property is allowed:
+		//	postData:
+		//		String. Send raw data in the body of the POST request.
+		return dojo.xhr("POST", args, true); // dojo.Deferred
+	};
+
+	dojo.rawXhrPut = dojo.xhrPut = function(/*dojo.__XhrArgs*/ args){
+		//	summary:
+		//		Sends an HTTP PUT request to the server. In addtion to the properties
+		//		listed for the dojo.__XhrArgs type, the following property is allowed:
+		//	putData:
+		//		String. Send raw data in the body of the PUT request.
+		return dojo.xhr("PUT", args, true); // dojo.Deferred
+	};
+
+	dojo.xhrDelete = function(/*dojo.__XhrArgs*/ args){
+		//	summary:
+		//		Sends an HTTP DELETE request to the server.
+		return dojo.xhr("DELETE", args); //dojo.Deferred
+	};
+
+	/*
+	dojo.wrapForm = function(formNode){
+		//summary:
+		//		A replacement for FormBind, but not implemented yet.
+
+		// FIXME: need to think harder about what extensions to this we might
+		// want. What should we allow folks to do w/ this? What events to
+		// set/send?
+		throw new Error("dojo.wrapForm not yet implemented");
+	}
+	*/
+
+	dojo._isDocumentOk = function(http){
+		var stat = http.status || 0;
+		stat =
+			(stat >= 200 && stat < 300) || // allow any 2XX response code
+			stat == 304 ||                 // or, get it out of the cache
+			stat == 1223 ||                // or, Internet Explorer mangled the status code
+			!stat;                         // or, we're Titanium/browser chrome/chrome extension requesting a local file
+		return stat; // Boolean
+	};
+
+	dojo._getText = function(url){
+		var result;
+		dojo.xhrGet({url:url, sync:true, load:function(text){
+			result = text;
+		}});
+		return result;
+	};
+
+	// Add aliases for static functions to dojo.xhr since dojo.xhr is what's returned from this module
+	lang.mixin(dojo.xhr, {
+		_xhrObj: dojo._xhrObj,
+		fieldToObject: domForm.fieldToObject,
+		formToObject: domForm.toObject,
+		objectToQuery: ioq.objectToQuery,
+		formToQuery: domForm.toQuery,
+		formToJson: domForm.toJson,
+		queryToObject: ioq.queryToObject,
+		contentHandlers: handlers,
+		_ioSetArgs: dojo._ioSetArgs,
+		_ioCancelAll: dojo._ioCancelAll,
+		_ioNotifyStart: dojo._ioNotifyStart,
+		_ioWatch: dojo._ioWatch,
+		_ioAddQueryToUrl: dojo._ioAddQueryToUrl,
+		_isDocumentOk: dojo._isDocumentOk,
+		_getText: dojo._getText,
+		get: dojo.xhrGet,
+		post: dojo.xhrPost,
+		put: dojo.xhrPut,
+		del: dojo.xhrDelete	// because "delete" is a reserved word
+	});
+
+	return dojo.xhr;
+});