remove dojo uncompressed files

21 files changed, 0 insertions, 6686 deletions

diff --git a/lib/dojo/_base/Color.js.uncompressed.js b/lib/dojo/_base/Color.js.uncompressed.js
deleted file mode 100644
index dba93b8f4..000000000
--- a/lib/dojo/_base/Color.js.uncompressed.js
+++ /dev/null
@@ -1,214 +0,0 @@
-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 `Color` object
-		//		and creates a new Color instance to work from.
-		//
-		// example:
-		//		Work with a Color instance:
-		//	 | var c = new 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 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?
-	Color.named = {
-		// summary:
-		//		Dictionary list of all CSS named colors, by name. Values are 3-item arrays with corresponding RG and B values.
-		"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 `Color` object
-			//		and sets this color instance to that value.
-			//
-			// example:
-			//	|	var c = new 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;	// 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;	// Color
-		},
-		toRgb: function(){
-			// summary:
-			//		Returns 3 component array of rgb values
-			// example:
-			//	|	var c = new 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 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 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(
-		/*Color*/ start,
-		/*Color*/ end,
-		/*Number*/ weight,
-		/*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 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();	// Color
-	};
-
-	Color.fromRgb = dojo.colorFromRgb = function(/*String*/ color, /*Color?*/ obj){
-		// summary:
-		//		Returns a `Color` instance from a string of the form
-		//		"rgb(...)" or "rgba(...)". Optionally accepts a `Color`
-		//		object to update with the parsed value and return instead of
-		//		creating a new object.
-		// returns:
-		//		A 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);	// Color
-	};
-
-	Color.fromHex = dojo.colorFromHex = function(/*String*/ color, /*Color?*/ obj){
-		// summary:
-		//		Converts a hex string with a '#' prefix to a color object.
-		//		Supports 12-bit #rgb shorthand. Optionally accepts a
-		//		`Color` object to update with the parsed value.
-		//
-		// returns:
-		//		A 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; // 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;	// Color
-	};
-
-	Color.fromArray = dojo.colorFromArray = function(/*Array*/ a, /*Color?*/ obj){
-		// summary:
-		//		Builds a `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 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();	// Color
-	};
-
-	Color.fromString = dojo.colorFromString = function(/*String*/ str, /*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 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);	// Color
-	};
-
-	return Color;
-});
diff --git a/lib/dojo/_base/Deferred.js.uncompressed.js b/lib/dojo/_base/Deferred.js.uncompressed.js
deleted file mode 100644
index 7c2cedacc..000000000
--- a/lib/dojo/_base/Deferred.js.uncompressed.js
+++ /dev/null
@@ -1,349 +0,0 @@
-define("dojo/_base/Deferred", [
-	"./kernel",
-	"../Deferred",
-	"../promise/Promise",
-	"../errors/CancelError",
-	"../has",
-	"./lang",
-	"../when"
-], function(dojo, NewDeferred, Promise, CancelError, has, lang, when){
-	// module:
-	//		dojo/_base/Deferred
-
-	var mutator = function(){};
-	var freeze = Object.freeze || function(){};
-	// A deferred provides an API for creating and resolving a promise.
-	var Deferred = dojo.Deferred = function(/*Function?*/ canceller){
-		// summary:
-		//		Deprecated.   This module defines the legacy dojo/_base/Deferred API.
-		//		New code should use dojo/Deferred instead.
-		// description:
-		//		The 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 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 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 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 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 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 = new 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(has("config-useDeferredInstrumentation")){
-					if(isError && NewDeferred.instrumentRejected){
-						NewDeferred.instrumentRejected(result, !!func);
-					}
-				}
-				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;
-			if(has("config-useDeferredInstrumentation")){
-				if(NewDeferred.instrumentRejected){
-					NewDeferred.instrumentRejected(error, !!nextListener);
-				}
-			}
-			complete(error);
-			this.results = [null, 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;	// 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 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 CancelError(error);
-					}
-					error.log = false;
-					deferred.reject(error);
-				}
-			}
-		};
-		freeze(promise);
-	};
-	lang.extend(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));	// 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));	// 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);	// Deferred
-		},
-		fired: -1
-	});
-
-	Deferred.when = dojo.when = when;
-
-	return Deferred;
-});
diff --git a/lib/dojo/_base/NodeList.js.uncompressed.js b/lib/dojo/_base/NodeList.js.uncompressed.js
deleted file mode 100644
index f9e9070f1..000000000
--- a/lib/dojo/_base/NodeList.js.uncompressed.js
+++ /dev/null
@@ -1,110 +0,0 @@
-define("dojo/_base/NodeList", ["./kernel", "../query", "./array", "./html", "../NodeList-dom"], function(dojo, query, array){
-	// module:
-	//		dojo/_base/NodeList
-
-	/*=====
-	return {
-		// summary:
-		//		This module extends dojo/NodeList with the legacy connect(), coords(),
-		//		blur(), focus(), change(), click(), error(), keydown(), keypress(),
-		//		keyup(), load(), mousedown(), mouseenter(), mouseleave(), mousemove(),
-		//		mouseout(), mouseover(), mouseup(), and submit() methods.
-	};
-	=====*/
- 
-	var NodeList = query.NodeList,
-		nlp = NodeList.prototype;
-
-	nlp.connect = NodeList._adaptAsForEach(function(){
-		// don't bind early to dojo.connect since we no longer explicitly depend on it
-		return dojo.connect.apply(this, arguments);
-	});
-	/*=====
-	nlp.connect = function(methodName, objOrFunc, funcName){
-		// summary:
-		//		Attach event handlers to every item of the NodeList. Uses dojo.connect()
-		//		so event properties are normalized.
-		//
-		//		Application must manually require() "dojo/_base/connect" before using this method.
-		// 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
-		//		|	query("div:nth-child(odd)").connect("onclick", function(e){
-		//		|		console.log("clicked!");
-		//		|	});
-		// example:
-		//		attach foo.bar() to every odd div's onmouseover
-		//		|	query("div:nth-child(odd)").connect("onmouseover", foo, "bar");
-
-		return null;	// NodeList
-	};
-	=====*/
-
-	nlp.coords = NodeList._adaptAsMap(dojo.coords);
-	/*=====
-	nlp.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 `domGeom.coords`, though assumes
-		//		the node passed is each node in this list.
-
-		return []; // Array
-	};
-	=====*/
-
-	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 NodeList;
-});
diff --git a/lib/dojo/_base/array.js.uncompressed.js b/lib/dojo/_base/array.js.uncompressed.js
deleted file mode 100644
index eb8b7c391..000000000
--- a/lib/dojo/_base/array.js.uncompressed.js
+++ /dev/null
@@ -1,343 +0,0 @@
-define("dojo/_base/array", ["./kernel", "../has", "./lang"], function(dojo, has, lang){
-	// module:
-	//		dojo/_base/array
-
-	// our old simple function builder stuff
-	var cache = {}, u;
-
-	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
-		};
-	}
-
-	// 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 array = {
-		// summary:
-		//		The Javascript v1.6 array extensions.
-
-		every: everyOrSome(false),
-		/*=====
-		 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
-			 //	|	array.every([1, 2, 3, 4], function(item){ return item>1; });
-			 // example:
-			 //	|	// returns true
-			 //	|	array.every([1, 2, 3, 4], function(item){ return item>0; });
-		 },
-		 =====*/
-
-		some: everyOrSome(true),
-		/*=====
-		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
-			//	| array.some([1, 2, 3, 4], function(item){ return item>1; });
-			// example:
-			//	| // is false
-			//	| array.some([1, 2, 3, 4], function(item){ return item<1; });
-		},
-		=====*/
-
-		indexOf: index(true),
-		/*=====
-		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
-		},
-		=====*/
-
-		lastIndexOf: index(false),
-		/*=====
-		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
-		},
-		=====*/
-
-		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 array.every() or array.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:
-			//	| array.forEach(
-			//	|		[ "thinger", "blah", "howdy", 10 ],
-			//	|		function(item){
-			//	|			console.log(item);
-			//	|		}
-			//	| );
-			// example:
-			//	| // log out the members and their indexes
-			//	| array.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
-			//	| array.forEach(
-			//	|		[ "thinger", "blah", "howdy", 10 ],
-			//	|		obj.callback,
-			//	|		obj
-			//	| );
-			//	|
-			//	| // alternately, we can accomplish the same thing with lang.hitch()
-			//	| array.forEach(
-			//	|		[ "thinger", "blah", "howdy", 10 ],
-			//	|		lang.hitch(obj, "callback")
-			//	| );
-			// arr: Array|String
-			// callback: Function|String
-			// thisObject: Object?
-
-			var i = 0, l = arr && arr.length || 0;
-			if(l && typeof arr == "string") arr = arr.split("");
-			if(typeof callback == "string") callback = cache[callback] || buildFn(callback);
-			if(thisObject){
-				for(; i < l; ++i){
-					callback.call(thisObject, arr[i], i, arr);
-				}
-			}else{
-				for(; i < l; ++i){
-					callback(arr[i], i, arr);
-				}
-			}
-		},
-
-		map: function(arr, callback, thisObject, Ctr){
-			// 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]
-			//	| array.map([1, 2, 3, 4], function(item){ return item+1 });
-
-			// TODO: why do we have a non-standard signature here? do we need "Ctr"?
-			var i = 0, l = arr && arr.length || 0, out = new (Ctr || Array)(l);
-			if(l && typeof arr == "string") arr = arr.split("");
-			if(typeof callback == "string") callback = cache[callback] || buildFn(callback);
-			if(thisObject){
-				for(; i < l; ++i){
-					out[i] = callback.call(thisObject, arr[i], i, arr);
-				}
-			}else{
-				for(; i < l; ++i){
-					out[i] = callback(arr[i], i, arr);
-				}
-			}
-			return out; // Array
-		},
-
-		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]
-			//	| array.filter([1, 2, 3, 4], function(item){ return item>1; });
-
-			// TODO: do we need "Ctr" here like in map()?
-			var i = 0, l = arr && arr.length || 0, out = [], value;
-			if(l && typeof arr == "string") arr = arr.split("");
-			if(typeof callback == "string") callback = cache[callback] || buildFn(callback);
-			if(thisObject){
-				for(; i < l; ++i){
-					value = arr[i];
-					if(callback.call(thisObject, value, i, arr)){
-						out.push(value);
-					}
-				}
-			}else{
-				for(; i < l; ++i){
-					value = arr[i];
-					if(callback(value, i, arr)){
-						out.push(value);
-					}
-				}
-			}
-			return out; // Array
-		},
-
-		clearCache: function(){
-			cache = {};
-		}
-	};
-
-
-	 1  && lang.mixin(dojo, array);
-
-	return array;
-});
diff --git a/lib/dojo/_base/browser.js.uncompressed.js b/lib/dojo/_base/browser.js.uncompressed.js
deleted file mode 100644
index 4c607fd3b..000000000
--- a/lib/dojo/_base/browser.js.uncompressed.js
+++ /dev/null
@@ -1,28 +0,0 @@
-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
-
-	/*=====
-	return {
-		// summary:
-		//		This module causes the browser-only base modules to be loaded.
-	};
-	=====*/
-
-	return dojo;
-});
diff --git a/lib/dojo/_base/config.js.uncompressed.js b/lib/dojo/_base/config.js.uncompressed.js
deleted file mode 100644
index bbb564afd..000000000
--- a/lib/dojo/_base/config.js.uncompressed.js
+++ /dev/null
@@ -1,187 +0,0 @@
-define("dojo/_base/config", ["../has", "require"], function(has, require){
-	// module:
-	//		dojo/_base/config
-
-/*=====
-return {
-	// 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-unique 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
-	//		|	});
-
-	// 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: [deprecated] 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. Specifying
-	//		`djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent
-	//		of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple
-	//		modules may be configured via `djConfig.modulePaths`.
-	modulePaths: {},
-
-	// addOnLoad: Function|Array
-	//		Adds a callback via dojo/ready. Useful when Dojo is added after
-	//		the page loads and djConfig.afterOnLoad is true. Supports the same
-	//		arguments as dojo/ready. 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,
-
-	// parseOnLoad: Boolean
-	//		Run the parser after the page is loaded
-	parseOnLoad: false,
-
-	// require: String[]
-	//		An array of module names to be loaded immediately after dojo.js has been included
-	//		in a page.
-	require: [],
-
-	// defaultDuration: Number
-	//		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/topic.publish(). See dojo/main.__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,
-	
-	// deps: Function|Array
-	//		Defines dependencies to be used before the loader has been loaded.
-	//		When provided, they cause the loader to execute require(deps, callback) 
-	//		once it has finished loading. Should be used with callback.
-	deps: undefined,
-	
-	// callback: Function|Array
-	//		Defines a callback to be used when dependencies are defined before 
-	//		the loader has been loaded. When provided, they cause the loader to 
-	//		execute require(deps, callback) once it has finished loading. 
-	//		Should be used with deps.
-	callback: undefined,
-	
-	// deferredInstrumentation: Boolean
-	//		Whether deferred instrumentation should be loaded or included
-	//		in builds.
-	deferredInstrumentation: true,
-
-	// useDeferredInstrumentation: Boolean|String
-	//		Whether the deferred instrumentation should be used.
-	//
-	//		* `"report-rejections"`: report each rejection as it occurs.
-	//		* `true` or `1` or `"report-unhandled-rejections"`: wait 1 second
-	//			in an attempt to detect unhandled rejections.
-	useDeferredInstrumentation: "report-unhandled-rejections"
-};
-=====*/
-
-	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;
-});
-
diff --git a/lib/dojo/_base/connect.js.uncompressed.js b/lib/dojo/_base/connect.js.uncompressed.js
deleted file mode 100644
index 233d20bcc..000000000
--- a/lib/dojo/_base/connect.js.uncompressed.js
+++ /dev/null
@@ -1,374 +0,0 @@
-define("dojo/_base/connect", ["./kernel", "../on", "../topic", "../aspect", "./event", "../mouse", "./sniff", "./lang", "../keys"], function(dojo, on, hub, aspect, eventModule, mouse, has, lang){
-// module:
-//		dojo/_base/connect
-
-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 || dojo.global, event, method, true);
-	}
-	if(typeof event == "string" && event.substring(0, 2) == "on"){
-		event = event.substring(2);
-	}
-	if(!obj){
-		obj = dojo.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) && 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 = {
-	// 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.
-
-	_keypress:keypress,
-
-	connect:function(obj, event, context, method, dontFix){
-		// summary:
-		//		`dojo.connect` is a deprecated 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?
-		//		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
-
-		// 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){
-		// 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.
-
-		if(handle){
-			handle.remove();
-		}
-	},
-
-	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?
-		//		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" ]);
-		return hub.subscribe(topic, lang.hitch(context, method));
-	},
-
-	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" ]);
-		return hub.publish.apply(hub, [topic].concat(args));
-	},
-
-	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?
-		//		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");
-		var pf = function(){ connect.publish(topic, arguments); };
-		return event ? connect.connect(obj, event, pf) : connect.connect(obj, pf); //Handle
-	},
-
-	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
-	}
-};
-
-connect.unsubscribe = connect.disconnect;
-/*=====
- connect.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);
- };
- =====*/
-
- 1  && lang.mixin(dojo, connect);
-return connect;
-
-});
-
-
diff --git a/lib/dojo/_base/declare.js.uncompressed.js b/lib/dojo/_base/declare.js.uncompressed.js
deleted file mode 100644
index cb25e2873..000000000
--- a/lib/dojo/_base/declare.js.uncompressed.js
+++ /dev/null
@@ -1,1045 +0,0 @@
-define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, has, lang){
-	// module:
-	//		dojo/_base/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){
-		// summary:
-		//		Mix in properties skipping a constructor and decorating functions
-		//		like it is done by 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
-		//		declare() does.
-		//
-		//		It is meant to be used with classes and objects produced with
-		//		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 declare().
-		//
-		// example:
-		//	|	var A = declare(null, {
-		//	|		m1: function(){
-		//	|			console.log("A.m1");
-		//	|		},
-		//	|		m2: function(){
-		//	|			console.log("A.m2");
-		//	|		}
-		//	|	});
-		//	|	var B = 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
-
-		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;
-	}
-
-	function createSubclass(mixins){
-		return declare([this].concat(mixins));
-	}
-
-	// chained constructor compatible with the legacy 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 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 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 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 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){
-		// 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: dojo/_base/declare.__DeclareCreatedObject
-		//		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
-		//		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
-		//		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:
-		//	|	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 = declare(null, {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//	|	var MyClass1 = declare(MyBase, {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//	|	var MyClass2 = declare(MyBase, {
-		//	|		// constructor, properties, and methods go here
-		//	|		// ...
-		//	|	});
-		//	|	var MyDiamond = 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 = 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 = declare(null, {
-		//	|		"-chains-": {
-		//	|			destroy: "before"
-		//	|		}
-		//	|	});
-		//	|	var B = declare(A, {
-		//	|		constructor: function(){
-		//	|			console.log("B.constructor");
-		//	|		},
-		//	|		destroy: function(){
-		//	|			console.log("B.destroy");
-		//	|		}
-		//	|	});
-		//	|	var C = 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 = declare(null, {
-		//	|		"-chains-": {
-		//	|			constructor: "manual"
-		//	|		}
-		//	|	});
-		//	|	var B = declare(A, {
-		//	|		constructor: function(){
-		//	|			// ...
-		//	|			// call the base constructor with new parameters
-		//	|			this.inherited(arguments, [1, 2, 3]);
-		//	|			// ...
-		//	|		}
-		//	|	});
-		//
-		// example:
-		//	|	var A = declare(null, {
-		//	|		"-chains-": {
-		//	|			m1: "before"
-		//	|		},
-		//	|		m1: function(){
-		//	|			console.log("A.m1");
-		//	|		},
-		//	|		m2: function(){
-		//	|			console.log("A.m2");
-		//	|		}
-		//	|	});
-		//	|	var B = 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
-
-		// 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.createSubclass = createSubclass;
-		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
-	}
-
-	/*=====
-	declare.__DeclareCreatedObject = {
-		// summary:
-		//		dojo/_base/declare() returns a constructor `C`.   `new C()` returns an Object with the following
-		//		methods, in addition to the methods and properties specified via the arguments passed to declare().
-
-		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
-			//		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
-			//		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 = 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 = 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
-		},
-
-		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
-			//		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 = 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
-		},
-
-		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
-			//		declare() to determine of they support a certain interface or
-			//		not. It models "instanceof" operator.
-			//
-			// example:
-			//	|	var A = declare(null, {
-			//	|		// constructor, properties, and methods go here
-			//	|		// ...
-			//	|	});
-			//	|	var B = declare(null, {
-			//	|		// constructor, properties, and methods go here
-			//	|		// ...
-			//	|	});
-			//	|	var C = declare([A, B], {
-			//	|		// constructor, properties, and methods go here
-			//	|		// ...
-			//	|	});
-			//	|	var D = 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
-		},
-
-		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
-			//		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 declare(). It is implemented
-			//		using dojo.safeMixin, and it skips a constructor property,
-			//		and properly decorates copied functions.
-			//
-			// example:
-			//	|	var A = declare(null, {
-			//	|		m1: function(){},
-			//	|		s1: "Popokatepetl"
-			//	|	});
-			//	|	A.extend({
-			//	|		m1: function(){},
-			//	|		m2: function(){},
-			//	|		f1: true,
-			//	|		d1: 42
-			//	|	});
-		}
-	};
-	=====*/
-
-	// For back-compat, remove for 2.0
-	dojo.safeMixin = declare.safeMixin = safeMixin;
-	dojo.declare = declare;
-
-	return declare;
-});
diff --git a/lib/dojo/_base/event.js.uncompressed.js b/lib/dojo/_base/event.js.uncompressed.js
deleted file mode 100644
index 8a0597f49..000000000
--- a/lib/dojo/_base/event.js.uncompressed.js
+++ /dev/null
@@ -1,59 +0,0 @@
-define("dojo/_base/event", ["./kernel", "../on", "../has", "../dom-geometry"], function(dojo, on, has, dom){
-	// module:
-	//		dojo/_base/event
-
-	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;
-		};		
-	}
-	
-	var ret = {
-		// summary:
-		//		This module defines dojo DOM event API.   Usually you should use dojo/on, and evt.stopPropagation() +
-		//		evt.preventDefault(), rather than this module.
-
-		fix: 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
-		},
-	
-		stop: 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);
-			}
-		}
-	};
-
-	if( 1 ){
-		dojo.fixEvent = ret.fix;
-		dojo.stopEvent = ret.stop;
-	}
-
-	return ret;
-});
diff --git a/lib/dojo/_base/fx.js.uncompressed.js b/lib/dojo/_base/fx.js.uncompressed.js
deleted file mode 100644
index b3568bfc5..000000000
--- a/lib/dojo/_base/fx.js.uncompressed.js
+++ /dev/null
@@ -1,670 +0,0 @@
-define("dojo/_base/fx", ["./kernel", "./config", /*===== "./declare", =====*/ "./lang", "../Evented", "./Color", "./connect", "./sniff", "../dom", "../dom-style"],
-	function(dojo, config, /*===== declare, =====*/ lang, Evented, Color, connect, has, dom, style){
-	// module:
-	//		dojo/_base/fx
-	// 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;
-
-	// Module export
-	var basefx = {
-		// summary:
-		//		This module defines the base dojo/_base/fx implementation.
-	};
-
-	var _Line = basefx._Line = function(/*int*/ start, /*int*/ end){
-		// summary:
-		//		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;
-	};
-
-	_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
-	};
-
-	var Animation = basefx.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 `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 _Line(this.curve[0], this.curve[1]);
-		}
-
-	};
-	Animation.prototype = new Evented();
-
-	lang.extend(Animation, {
-		// duration: Integer
-		//		The time in milliseconds the animation will take to run
-		duration: 350,
-
-	/*=====
-		// curve: _Line|Array
-		//		A two element array of start and end values, or a `_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 _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 Animation begins playing (synchronous)
-		beforeBegin: null,
-
-		// onBegin: Event?
-		//		Synthetic event fired as a Animation begins playing (useful?)
-		onBegin: null,
-
-		// onAnimate: Event?
-		//		Synthetic event fired at each interval of the Animation
-		onAnimate: null,
-
-		// onEnd: Event?
-		//		Synthetic event fired after the final frame of the Animation
-		onEnd: null,
-
-		// onPlay: Event?
-		//		Synthetic event fired any time the Animation is play()'ed
-		onPlay: null,
-
-		// onPause: Event?
-		//		Synthetic event fired when the Animation is paused
-		onPause: null,
-
-		// onStop: Event
-		//		Synthetic event fires when the 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 this Animation
-			//		instance.
-			// evt:
-			//		The event to fire.
-			// args:
-			//		The arguments to pass to the event.
-			var a = args||[];
-			if(this[evt]){
-				if(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; // 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: 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;	// 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; // Animation
-		},
-
-		pause: function(){
-			// summary:
-			//		Pauses a running animation.
-			var _t = this;
-			if(_t._delayTimer){ _t._clearTimer(); }
-			_t._stopTimer();
-			if(!_t._active){ return _t; /*Animation*/ }
-			_t._paused = true;
-			_t._fire("onPause", [_t.curve.getValue(_t._getStep())]);
-			return _t; // 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; // 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; /* Animation */ }
-			_t._stopTimer();
-			if(gotoEnd){
-				_t._percent = 1;
-			}
-			_t._fire("onStop", [_t.curve.getValue(_t._getStep())]);
-			_t._active = _t._paused = false;
-			return _t; // 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();
-				// Allow durations of 0 (instant) by setting step to 1 - see #13798
-				var step = _t.duration === 0 ? 1 : (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; // 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(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(){};
-
-	basefx._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 = basefx.animateProperty(fArgs);
-		connect.connect(anim, "beforeBegin", lang.partial(_makeFadeable, fArgs.node));
-
-		return anim; // Animation
-	};
-
-	/*=====
-	var __FadeArgs = declare(null, {
-		// node: DOMNode|String
-		//		The node referenced in the animation
-		// duration: Integer?
-		//		Duration of the animation in milliseconds.
-		// easing: Function?
-		//		An easing function.
-	});
-	=====*/
-
-	basefx.fadeIn = function(/*__FadeArgs*/ args){
-		// summary:
-		//		Returns an animation that will fade node defined in 'args' from
-		//		its current opacity to fully opaque.
-		return basefx._fade(_mixin({ end: 1 }, args)); // Animation
-	};
-
-	basefx.fadeOut = function(/*__FadeArgs*/ args){
-		// summary:
-		//		Returns an animation that will fade node defined in 'args'
-		//		from its current opacity to fully transparent.
-		return basefx._fade(_mixin({ end: 0 }, args)); // Animation
-	};
-
-	basefx._defaultEasing = function(/*Decimal?*/ n){
-		// summary:
-		//		The default easing function for 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;
-	};
-
-	/*=====
-	var __AnimArgs = declare(__FadeArgs, {
-		// properties: Object?
-		//		A hash map of style properties to Objects describing the transition,
-		//		such as the properties of _Line with an additional 'units' property
-		properties: {}
-
-		//TODOC: add event callbacks
-	});
-	=====*/
-
-	basefx.animateProperty = function(/*__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:
-		//		Foundation of most `dojo/_base/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.
-		//	|	basefx.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 omitted.
-		//
-		// example:
-		//		Animate width, height, and padding over 2 seconds... the
-		//		pedantic way:
-		//	|	basefx.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.
-		//	|	basefx.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 `Animation`s, animateProperty returns a handle to the
-		//		Animation instance, which fires the events common to Dojo FX. Use `aspect.after`
-		//		to access these events outside of the Animation definition:
-		//	|	var anim = basefx.animateProperty({
-		//	|		node:"someId",
-		//	|		properties:{
-		//	|			width:400, height:500
-		//	|		}
-		//	|	});
-		//	|	aspect.after(anim, "onEnd", function(){
-		//	|		console.log("animation ended");
-		//	|	}, true);
-		//	|	// 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 directly to callbacks.
-		//	|	basefx.animateProperty({
-		//	|		node:"mine",
-		//	|		properties:{
-		//	|			height:function(node){
-		//	|				// shrink this node by 50%
-		//	|				return domGeom.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 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){
-					// domStyle.get(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; // Animation
-	};
-
-	basefx.anim = function(	/*DOMNode|String*/	node,
-							/*Object*/			properties,
-							/*Integer?*/		duration,
-							/*Function?*/		easing,
-							/*Function?*/		onEnd,
-							/*Integer?*/		delay){
-		// summary:
-		//		A simpler interface to `animateProperty()`, also returns
-		//		an instance of `Animation` but begins the animation
-		//		immediately, unlike nearly every other Dojo animation API.
-		// description:
-		//		Simpler (but somewhat less powerful) version
-		//		of `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 `Animation` object returned will be already playing, 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
-		//	|	basefx.anim("id", { opacity: 0 });
-		// example:
-		//		Fade out a node over a full second
-		//	|	basefx.anim("id", { opacity: 0 }, 1000);
-		return basefx.animateProperty({ // Animation
-			node: node,
-			duration: duration || Animation.prototype.duration,
-			properties: properties,
-			easing: easing,
-			onEnd: onEnd
-		}).play(delay || 0);
-	};
-
-
-	if( 1 ){
-		_mixin(dojo, basefx);
-		// Alias to drop come 2.0:
-		dojo._Animation = Animation;
-	}
-
-	return basefx;
-});
diff --git a/lib/dojo/_base/html.js.uncompressed.js b/lib/dojo/_base/html.js.uncompressed.js
deleted file mode 100644
index f439d0d54..000000000
--- a/lib/dojo/_base/html.js.uncompressed.js
+++ /dev/null
@@ -1,392 +0,0 @@
-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
-
-	/*=====
-	return {
-		// 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 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.uncompressed.js b/lib/dojo/_base/json.js.uncompressed.js
deleted file mode 100644
index 525c04880..000000000
--- a/lib/dojo/_base/json.js.uncompressed.js
+++ /dev/null
@@ -1,91 +0,0 @@
-define("dojo/_base/json", ["./kernel", "../json"], function(dojo, json){
-
-// module:
-//		dojo/_base/json
-
-/*=====
-return {
-	// 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.uncompressed.js b/lib/dojo/_base/kernel.js.uncompressed.js
deleted file mode 100644
index 44b2f9b28..000000000
--- a/lib/dojo/_base/kernel.js.uncompressed.js
+++ /dev/null
@@ -1,299 +0,0 @@
-define("dojo/_base/kernel", ["../has", "./config", "require", "module"], function(has, config, require, module){
-	// module:
-	//		dojo/_base/kernel
-
-	// This module is the foundational module of the dojo boot sequence; it defines the dojo object.
-
-	var
-		// loop variables for this module
-		i, p,
-
-		// create dojo, dijit, and dojox
-		// FIXME: in 2.0 remove dijit, dojox being created by dojo
-		dijit = {},
-		dojox = {},
-		dojo = {
-			// summary:
-			//		This module is the foundational module of the dojo boot sequence; it defines the dojo object.
-
-			// notice dojo takes ownership of the value of the config module
-			config:config,
-			global:this,
-			dijit:dijit,
-			dojox:dojox
-		};
-
-
-	// Configure the scope map. For a 100% AMD application, the scope map is not needed other than to provide
-	// a _scopeName property for the dojo, dijit, and dojox root object so those packages can create
-	// unique names in the global space.
-	//
-	// Built, legacy modules use the scope map to allow those modules to be expressed as if dojo, dijit, and dojox,
-	// where global when in fact they are either global under different names or not global at all. In v1.6-, the
-	// config variable "scopeMap" was used to map names as used within a module to global names. This has been
-	// subsumed by the AMD map configuration variable which can relocate packages to different names. For backcompat,
-	// only the "*" mapping is supported. See http://livedocs.dojotoolkit.org/developer/design/loader#legacy-cross-domain-mode for details.
-	//
-	// The following computations contort the packageMap for this dojo instance into a scopeMap.
-	var scopeMap =
-			// a map from a name used in a legacy module to the (global variable name, object addressed by that name)
-			// always map dojo, dijit, and dojox
-			{
-				dojo:["dojo", dojo],
-				dijit:["dijit", dijit],
-				dojox:["dojox", dojox]
-			},
-
-		packageMap =
-			// the package map for this dojo instance; note, a foreign loader or no pacakgeMap results in the above default config
-			(require.map && require.map[module.id.match(/[^\/]+/)[0]]),
-
-		item;
-
-
-	// process all mapped top-level names for this instance of dojo
-	for(p in packageMap){
-		if(scopeMap[p]){
-			// mapped dojo, dijit, or dojox
-			scopeMap[p][0] = packageMap[p];
-		}else{
-			// some other top-level name
-			scopeMap[p] = [packageMap[p], {}];
-		}
-	}
-
-	// publish those names to _scopeName and, optionally, the global namespace
-	for(p in scopeMap){
-		item = scopeMap[p];
-		item[1]._scopeName = item[0];
-		if(!config.noGlobals){
-			this[item[0]] = item[1];
-		}
-	}
-	dojo.scopeMap = scopeMap;
-
-	/*===== dojo.__docParserConfigureScopeMap(scopeMap); =====*/
-
-	// FIXME: dojo.baseUrl and dojo.config.baseUrl should be deprecated
-	dojo.baseUrl = dojo.config.baseUrl = require.baseUrl;
-	dojo.isAsync = ! 1  || require.async;
-	dojo.locale = config.locale;
-
-	var rev = "$Rev: 30226 $".match(/\d+/);
-	dojo.version = {
-		// summary:
-		//		Version number of the Dojo Toolkit
-		// description:
-		//		Hash about the version, including
-		//
-		//		- major: Integer: Major version. If total version is "1.2.0beta1", will be 1
-		//		- minor: Integer: Minor version. If total version is "1.2.0beta1", will be 2
-		//		- patch: Integer: Patch version. If total version is "1.2.0beta1", will be 0
-		//		- flag: String: Descriptor flag. If total version is "1.2.0beta1", will be "beta1"
-		//		- revision: Number: The SVN rev from which dojo was pulled
-
-		major: 1, minor: 8, patch: 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.
-	 1 || has.add("extend-dojo", 1);
-
-
-	(Function("d", "d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo);
-	/*=====
-	dojo.eval = function(scriptText){
-		// summary:
-		//		A legacy method created for use exclusively by internal Dojo methods. Do not use this method
-		//		directly unless you understand its possibly-different implications on the platforms your are targeting.
-		// description:
-		//		Makes an attempt to evaluate scriptText in the global scope. The function works correctly for browsers
-		//		that support indirect eval.
-		//
-		//		As usual, IE does not. On IE, the only way to implement global eval is to
-		//		use execScript. Unfortunately, execScript does not return a value and breaks some current usages of dojo.eval.
-		//		This implementation uses the technique of executing eval in the scope of a function that is a single scope
-		//		frame below the global scope; thereby coming close to the global scope. Note carefully that
-		//
-		//		dojo.eval("var pi = 3.14;");
-		//
-		//		will define global pi in non-IE environments, but define pi only in a temporary local scope for IE. If you want
-		//		to define a global variable using dojo.eval, write something like
-		//
-		//		dojo.eval("window.pi = 3.14;")
-		// scriptText:
-		//		The text to evaluation.
-		// returns:
-		//		The result of the evaluation. Often `undefined`
-	};
-	=====*/
-
-
-	if( 0 ){
-		dojo.exit = function(exitcode){
-			quit(exitcode);
-		};
-	}else{
-		dojo.exit = function(){
-		};
-	}
-
-	 1 || has.add("dojo-guarantee-console",
-		// ensure that console.log, console.warn, etc. are defined
-		1
-	);
-	if( 1 ){
-		typeof console != "undefined" || (console = {});
-		//	Be careful to leave 'log' always at the end
-		var cn = [
-			"assert", "count", "debug", "dir", "dirxml", "error", "group",
-			"groupEnd", "info", "profile", "profileEnd", "time", "timeEnd",
-			"trace", "warn", "log"
-		];
-		var tn;
-		i = 0;
-		while((tn = cn[i++])){
-			if(!console[tn]){
-				(function(){
-					var tcn = tn + "";
-					console[tcn] = ('log' in console) ? function(){
-						var a = Array.apply({}, arguments);
-						a.unshift(tcn + ":");
-						console["log"](a.join(" "));
-					} : function(){};
-					console[tcn]._fake = true;
-				})();
-			}
-		}
-	}
-
-	has.add("dojo-debug-messages",
-		// include dojo.deprecated/dojo.experimental implementations
-		!!config.isDebug
-	);
-	dojo.deprecated = dojo.experimental =  function(){};
-	if(has("dojo-debug-messages")){
-		dojo.deprecated = function(/*String*/ behaviour, /*String?*/ extra, /*String?*/ removal){
-			// summary:
-			//		Log a debug message to indicate that a behavior has been
-			//		deprecated.
-			// behaviour: String
-			//		The API or behavior being deprecated. Usually in the form
-			//		of "myApp.someFunction()".
-			// extra: String?
-			//		Text to append to the message. Often provides advice on a
-			//		new function or facility to achieve the same goal during
-			//		the deprecation period.
-			// removal: String?
-			//		Text to indicate when in the future the behavior will be
-			//		removed. Usually a version number.
-			// example:
-			//	| dojo.deprecated("myApp.getTemp()", "use myApp.getLocaleTemp() instead", "1.0");
-
-			var message = "DEPRECATED: " + behaviour;
-			if(extra){ message += " " + extra; }
-			if(removal){ message += " -- will be removed in version: " + removal; }
-			console.warn(message);
-		};
-
-		dojo.experimental = function(/* String */ moduleName, /* String? */ extra){
-			// summary:
-			//		Marks code as experimental.
-			// description:
-			//		This can be used to mark a function, file, or module as
-			//		experimental.	 Experimental code is not ready to be used, and the
-			//		APIs are subject to change without notice.	Experimental code may be
-			//		completed deleted without going through the normal deprecation
-			//		process.
-			// moduleName: String
-			//		The name of a module, or the name of a module file or a specific
-			//		function
-			// extra: String?
-			//		some additional message for the user
-			// example:
-			//	| dojo.experimental("dojo.data.Result");
-			// example:
-			//	| dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA");
-
-			var message = "EXPERIMENTAL: " + moduleName + " -- APIs subject to change without notice.";
-			if(extra){ message += " " + extra; }
-			console.warn(message);
-		};
-	}
-
-	 1 || has.add("dojo-modulePaths",
-		// consume dojo.modulePaths processing
-		1
-	);
-	if( 1 ){
-		// notice that modulePaths won't be applied to any require's before the dojo/_base/kernel factory is run;
-		// this is the v1.6- behavior.
-		if(config.modulePaths){
-			dojo.deprecated("dojo.modulePaths", "use paths configuration");
-			var paths = {};
-			for(p in config.modulePaths){
-				paths[p.replace(/\./g, "/")] = config.modulePaths[p];
-			}
-			require({paths:paths});
-		}
-	}
-
-	 1 || has.add("dojo-moduleUrl",
-		// include dojo.moduleUrl
-		1
-	);
-	if( 1 ){
-		dojo.moduleUrl = function(/*String*/module, /*String?*/url){
-			// summary:
-			//		Returns a URL relative to a module.
-			// example:
-			//	|	var pngPath = dojo.moduleUrl("acme","images/small.png");
-			//	|	console.dir(pngPath); // list the object properties
-			//	|	// create an image and set it's source to pngPath's value:
-			//	|	var img = document.createElement("img");
-			//	|	img.src = pngPath;
-			//	|	// add our image to the document
-			//	|	dojo.body().appendChild(img);
-			// example:
-			//		you may de-reference as far as you like down the package
-			//		hierarchy.  This is sometimes handy to avoid lenghty relative
-			//		urls or for building portable sub-packages. In this example,
-			//		the `acme.widget` and `acme.util` directories may be located
-			//		under different roots (see `dojo.registerModulePath`) but the
-			//		the modules which reference them can be unaware of their
-			//		relative locations on the filesystem:
-			//	|	// somewhere in a configuration block
-			//	|	dojo.registerModulePath("acme.widget", "../../acme/widget");
-			//	|	dojo.registerModulePath("acme.util", "../../util");
-			//	|
-			//	|	// ...
-			//	|
-			//	|	// code in a module using acme resources
-			//	|	var tmpltPath = dojo.moduleUrl("acme.widget","templates/template.html");
-			//	|	var dataPath = dojo.moduleUrl("acme.util","resources/data.json");
-
-			dojo.deprecated("dojo.moduleUrl()", "use require.toUrl", "2.0");
-
-			// require.toUrl requires a filetype; therefore, just append the suffix "/*.*" to guarantee a filetype, then
-			// remove the suffix from the result. This way clients can request a url w/out a filetype. This should be
-			// rare, but it maintains backcompat for the v1.x line (note: dojo.moduleUrl will be removed in v2.0).
-			// Notice * is an illegal filename so it won't conflict with any real path map that may exist the paths config.
-			var result = null;
-			if(module){
-				result = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : "") + "/*.*").replace(/\/\*\.\*/, "") + (url ? "" : "/");
-			}
-			return result;
-		};
-	}
-
-	dojo._hasResource = {}; // for backward compatibility with layers built with 1.6 tooling
-
-	return dojo;
-});
diff --git a/lib/dojo/_base/lang.js.uncompressed.js b/lib/dojo/_base/lang.js.uncompressed.js
deleted file mode 100644
index 46bca1849..000000000
--- a/lib/dojo/_base/lang.js.uncompressed.js
+++ /dev/null
@@ -1,605 +0,0 @@
-define("dojo/_base/lang", ["./kernel", "../has", "../sniff"], function(dojo, has){
-	// module:
-	//		dojo/_base/lang
-
-	has.add("bug-for-in-skips-shadowed", function(){
-		// if true, the for-in iterator skips object properties that exist in Object's prototype (IE 6 - ?)
-		for(var i in {toString: 1}){
-			return 0;
-		}
-		return 1;
-	});
-
-	// Helper methods
-	var _extraNames =
-			has("bug-for-in-skips-shadowed") ?
-				"hasOwnProperty.valueOf.isPrototypeOf.propertyIsEnumerable.toLocaleString.toString.constructor".split(".") : [],
-
-		_extraLen = _extraNames.length,
-
-		getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){
-			var p, i = 0, dojoGlobal = dojo.global;
-			if(!context){
-				if(!parts.length){
-					return dojoGlobal;
-				}else{
-					p = parts[i++];
-					try{
-						context = dojo.scopeMap[p] && dojo.scopeMap[p][1];
-					}catch(e){}
-					context = context || (p in dojoGlobal ? dojoGlobal[p] : (create ? dojoGlobal[p] = {} : undefined));
-				}
-			}
-			while(context && (p = parts[i++])){
-				context = (p in context ? context[p] : (create ? context[p] = {} : undefined));
-			}
-			return context; // mixed
-		},
-
-		opts = Object.prototype.toString,
-
-		efficient = function(obj, offset, startWith){
-			return (startWith||[]).concat(Array.prototype.slice.call(obj, offset||0));
-		},
-
-		_pattern = /\{([^\}]+)\}/g;
-
-	// Module export
-	var lang = {
-		// summary:
-		//		This module defines Javascript language extensions.
-
-		// _extraNames: String[]
-		//		Lists property names that must be explicitly processed during for-in iteration
-		//		in environments that have has("bug-for-in-skips-shadowed") true.
-		_extraNames:_extraNames,
-
-		_mixin: function(dest, source, copyFunc){
-			// summary:
-			//		Copies/adds all properties of source to dest; returns dest.
-			// dest: Object
-			//		The object to which to copy/add all properties contained in source.
-			// source: Object
-			//		The object from which to draw all properties to copy into dest.
-			// copyFunc: Function?
-			//		The process used to copy/add a property in source; defaults to the Javascript assignment operator.
-			// returns:
-			//		dest, as modified
-			// description:
-			//		All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions
-			//		found in Object.prototype, are copied/added to dest. Copying/adding each particular property is
-			//		delegated to copyFunc (if any); copyFunc defaults to the Javascript assignment operator if not provided.
-			//		Notice that by default, _mixin executes a so-called "shallow copy" and aggregate types are copied/added by reference.
-			var name, s, i, empty = {};
-			for(name in source){
-				// the (!(name in empty) || empty[name] !== s) condition avoids copying properties in "source"
-				// inherited from Object.prototype.	 For example, if dest has a custom toString() method,
-				// don't overwrite it with the toString() method that source inherited from Object.prototype
-				s = source[name];
-				if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
-					dest[name] = copyFunc ? copyFunc(s) : s;
-				}
-			}
-
-			if(has("bug-for-in-skips-shadowed")){
-				if(source){
-					for(i = 0; i < _extraLen; ++i){
-						name = _extraNames[i];
-						s = source[name];
-						if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
-							dest[name] = copyFunc ? copyFunc(s) : s;
-						}
-					}
-				}
-			}
-
-			return dest; // Object
-		},
-
-		mixin: function(dest, sources){
-			// summary:
-			//		Copies/adds all properties of one or more sources to dest; returns dest.
-			// dest: Object
-			//		The object to which to copy/add all properties contained in source. If dest is falsy, then
-			//		a new object is manufactured before copying/adding properties begins.
-			// sources: Object...
-			//		One of more objects from which to draw all properties to copy into dest. sources are processed
-			//		left-to-right and if more than one of these objects contain the same property name, the right-most
-			//		value "wins".
-			// returns: Object
-			//		dest, as modified
-			// description:
-			//		All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions
-			//		found in Object.prototype, are copied/added from sources to dest. sources are processed left to right.
-			//		The Javascript assignment operator is used to copy/add each property; therefore, by default, mixin
-			//		executes a so-called "shallow copy" and aggregate types are copied/added by reference.
-			// example:
-			//		make a shallow copy of an object
-			//	|	var copy = lang.mixin({}, source);
-			// example:
-			//		many class constructors often take an object which specifies
-			//		values to be configured on the object. In this case, it is
-			//		often simplest to call `lang.mixin` on the `this` object:
-			//	|	declare("acme.Base", null, {
-			//	|		constructor: function(properties){
-			//	|			// property configuration:
-			//	|			lang.mixin(this, properties);
-			//	|
-			//	|			console.log(this.quip);
-			//	|			//	...
-			//	|		},
-			//	|		quip: "I wasn't born yesterday, you know - I've seen movies.",
-			//	|		// ...
-			//	|	});
-			//	|
-			//	|	// create an instance of the class and configure it
-			//	|	var b = new acme.Base({quip: "That's what it does!" });
-			// example:
-			//		copy in properties from multiple objects
-			//	|	var flattened = lang.mixin(
-			//	|		{
-			//	|			name: "Frylock",
-			//	|			braces: true
-			//	|		},
-			//	|		{
-			//	|			name: "Carl Brutanananadilewski"
-			//	|		}
-			//	|	);
-			//	|
-			//	|	// will print "Carl Brutanananadilewski"
-			//	|	console.log(flattened.name);
-			//	|	// will print "true"
-			//	|	console.log(flattened.braces);
-
-			if(!dest){ dest = {}; }
-			for(var i = 1, l = arguments.length; i < l; i++){
-				lang._mixin(dest, arguments[i]);
-			}
-			return dest; // Object
-		},
-
-		setObject: function(name, value, context){
-			// summary:
-			//		Set a property from a dot-separated string, such as "A.B.C"
-			// description:
-			//		Useful for longer api chains where you have to test each object in
-			//		the chain, or when you have an object reference in string format.
-			//		Objects are created as needed along `path`. Returns the passed
-			//		value if setting is successful or `undefined` if not.
-			// name: String
-			//		Path to a property, in the form "A.B.C".
-			// value: anything
-			//		value or object to place at location given by name
-			// context: Object?
-			//		Optional. Object to use as root of path. Defaults to
-			//		`dojo.global`.
-			// example:
-			//		set the value of `foo.bar.baz`, regardless of whether
-			//		intermediate objects already exist:
-			//	| lang.setObject("foo.bar.baz", value);
-			// example:
-			//		without `lang.setObject`, we often see code like this:
-			//	| // ensure that intermediate objects are available
-			//	| if(!obj["parent"]){ obj.parent = {}; }
-			//	| if(!obj.parent["child"]){ obj.parent.child = {}; }
-			//	| // now we can safely set the property
-			//	| obj.parent.child.prop = "some value";
-			//		whereas with `lang.setObject`, we can shorten that to:
-			//	| lang.setObject("parent.child.prop", "some value", obj);
-
-			var parts = name.split("."), p = parts.pop(), obj = getProp(parts, true, context);
-			return obj && p ? (obj[p] = value) : undefined; // Object
-		},
-
-		getObject: function(name, create, context){
-			// summary:
-			//		Get a property from a dot-separated string, such as "A.B.C"
-			// description:
-			//		Useful for longer api chains where you have to test each object in
-			//		the chain, or when you have an object reference in string format.
-			// name: String
-			//		Path to an property, in the form "A.B.C".
-			// create: Boolean?
-			//		Optional. Defaults to `false`. If `true`, Objects will be
-			//		created at any point along the 'path' that is undefined.
-			// context: Object?
-			//		Optional. Object to use as root of path. Defaults to
-			//		'dojo.global'. Null may be passed.
-			return getProp(name.split("."), create, context); // Object
-		},
-
-		exists: function(name, obj){
-			// summary:
-			//		determine if an object supports a given method
-			// description:
-			//		useful for longer api chains where you have to test each object in
-			//		the chain. Useful for object and method detection.
-			// name: String
-			//		Path to an object, in the form "A.B.C".
-			// obj: Object?
-			//		Object to use as root of path. Defaults to
-			//		'dojo.global'. Null may be passed.
-			// example:
-			//	| // define an object
-			//	| var foo = {
-			//	|		bar: { }
-			//	| };
-			//	|
-			//	| // search the global scope
-			//	| lang.exists("foo.bar"); // true
-			//	| lang.exists("foo.bar.baz"); // false
-			//	|
-			//	| // search from a particular scope
-			//	| lang.exists("bar", foo); // true
-			//	| lang.exists("bar.baz", foo); // false
-			return lang.getObject(name, false, obj) !== undefined; // Boolean
-		},
-
-		// Crockford (ish) functions
-
-		isString: function(it){
-			// summary:
-			//		Return true if it is a String
-			// it: anything
-			//		Item to test.
-			return (typeof it == "string" || it instanceof String); // Boolean
-		},
-
-		isArray: function(it){
-			// summary:
-			//		Return true if it is an Array.
-			//		Does not work on Arrays created in other windows.
-			// it: anything
-			//		Item to test.
-			return it && (it instanceof Array || typeof it == "array"); // Boolean
-		},
-
-		isFunction: function(it){
-			// summary:
-			//		Return true if it is a Function
-			// it: anything
-			//		Item to test.
-			return opts.call(it) === "[object Function]";
-		},
-
-		isObject: function(it){
-			// summary:
-			//		Returns true if it is a JavaScript object (or an Array, a Function
-			//		or null)
-			// it: anything
-			//		Item to test.
-			return it !== undefined &&
-				(it === null || typeof it == "object" || lang.isArray(it) || lang.isFunction(it)); // Boolean
-		},
-
-		isArrayLike: function(it){
-			// summary:
-			//		similar to isArray() but more permissive
-			// it: anything
-			//		Item to test.
-			// returns:
-			//		If it walks like a duck and quacks like a duck, return `true`
-			// description:
-			//		Doesn't strongly test for "arrayness".  Instead, settles for "isn't
-			//		a string or number and has a length property". Arguments objects
-			//		and DOM collections will return true when passed to
-			//		isArrayLike(), but will return false when passed to
-			//		isArray().
-			return it && it !== undefined && // Boolean
-				// keep out built-in constructors (Number, String, ...) which have length
-				// properties
-				!lang.isString(it) && !lang.isFunction(it) &&
-				!(it.tagName && it.tagName.toLowerCase() == 'form') &&
-				(lang.isArray(it) || isFinite(it.length));
-		},
-
-		isAlien: function(it){
-			// summary:
-			//		Returns true if it is a built-in function or some other kind of
-			//		oddball that *should* report as a function but doesn't
-			return it && !lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
-		},
-
-		extend: function(ctor, props){
-			// summary:
-			//		Adds all properties and methods of props to constructor's
-			//		prototype, making them available to all instances created with
-			//		constructor.
-			// ctor: Object
-			//		Target constructor to extend.
-			// props: Object
-			//		One or more objects to mix into ctor.prototype
-			for(var i=1, l=arguments.length; i<l; i++){
-				lang._mixin(ctor.prototype, arguments[i]);
-			}
-			return ctor; // Object
-		},
-
-		_hitchArgs: function(scope, method){
-			var pre = lang._toArray(arguments, 2);
-			var named = lang.isString(method);
-			return function(){
-				// arrayify arguments
-				var args = lang._toArray(arguments);
-				// locate our method
-				var f = named ? (scope||dojo.global)[method] : method;
-				// invoke with collected args
-				return f && f.apply(scope || this, pre.concat(args)); // mixed
-			}; // Function
-		},
-
-		hitch: function(scope, method){
-			// summary:
-			//		Returns a function that will only ever execute in the a given scope.
-			//		This allows for easy use of object member functions
-			//		in callbacks and other places in which the "this" keyword may
-			//		otherwise not reference the expected scope.
-			//		Any number of default positional arguments may be passed as parameters
-			//		beyond "method".
-			//		Each of these values will be used to "placehold" (similar to curry)
-			//		for the hitched function.
-			// scope: Object
-			//		The scope to use when method executes. If method is a string,
-			//		scope is also the object containing method.
-			// method: Function|String...
-			//		A function to be hitched to scope, or the name of the method in
-			//		scope to be hitched.
-			// example:
-			//	|	lang.hitch(foo, "bar")();
-			//		runs foo.bar() in the scope of foo
-			// example:
-			//	|	lang.hitch(foo, myFunction);
-			//		returns a function that runs myFunction in the scope of foo
-			// example:
-			//		Expansion on the default positional arguments passed along from
-			//		hitch. Passed args are mixed first, additional args after.
-			//	|	var foo = { bar: function(a, b, c){ console.log(a, b, c); } };
-			//	|	var fn = lang.hitch(foo, "bar", 1, 2);
-			//	|	fn(3); // logs "1, 2, 3"
-			// example:
-			//	|	var foo = { bar: 2 };
-			//	|	lang.hitch(foo, function(){ this.bar = 10; })();
-			//		execute an anonymous function in scope of foo
-			if(arguments.length > 2){
-				return lang._hitchArgs.apply(dojo, arguments); // Function
-			}
-			if(!method){
-				method = scope;
-				scope = null;
-			}
-			if(lang.isString(method)){
-				scope = scope || dojo.global;
-				if(!scope[method]){ throw(['lang.hitch: scope["', method, '"] is null (scope="', scope, '")'].join('')); }
-				return function(){ return scope[method].apply(scope, arguments || []); }; // Function
-			}
-			return !scope ? method : function(){ return method.apply(scope, arguments || []); }; // Function
-		},
-
-		delegate: (function(){
-			// boodman/crockford delegation w/ cornford optimization
-			function TMP(){}
-			return function(obj, props){
-				TMP.prototype = obj;
-				var tmp = new TMP();
-				TMP.prototype = null;
-				if(props){
-					lang._mixin(tmp, props);
-				}
-				return tmp; // Object
-			};
-		})(),
-		/*=====
-		delegate: function(obj, props){
-			// summary:
-			//		Returns a new object which "looks" to obj for properties which it
-			//		does not have a value for. Optionally takes a bag of properties to
-			//		seed the returned object with initially.
-			// description:
-			//		This is a small implementation of the Boodman/Crockford delegation
-			//		pattern in JavaScript. An intermediate object constructor mediates
-			//		the prototype chain for the returned object, using it to delegate
-			//		down to obj for property lookup when object-local lookup fails.
-			//		This can be thought of similarly to ES4's "wrap", save that it does
-			//		not act on types but rather on pure objects.
-			// obj: Object
-			//		The object to delegate to for properties not found directly on the
-			//		return object or in props.
-			// props: Object...
-			//		an object containing properties to assign to the returned object
-			// returns:
-			//		an Object of anonymous type
-			// example:
-			//	|	var foo = { bar: "baz" };
-			//	|	var thinger = lang.delegate(foo, { thud: "xyzzy"});
-			//	|	thinger.bar == "baz"; // delegated to foo
-			//	|	foo.thud == undefined; // by definition
-			//	|	thinger.thud == "xyzzy"; // mixed in from props
-			//	|	foo.bar = "thonk";
-			//	|	thinger.bar == "thonk"; // still delegated to foo's bar
-		},
-		=====*/
-
-		_toArray: has("ie") ?
-			(function(){
-				function slow(obj, offset, startWith){
-					var arr = startWith||[];
-					for(var x = offset || 0; x < obj.length; x++){
-						arr.push(obj[x]);
-					}
-					return arr;
-				}
-				return function(obj){
-					return ((obj.item) ? slow : efficient).apply(this, arguments);
-				};
-			})() : efficient,
-		/*=====
-		 _toArray: function(obj, offset, startWith){
-			 // summary:
-			 //		Converts an array-like object (i.e. arguments, DOMCollection) to an
-			 //		array. Returns a new Array with the elements of obj.
-			 // obj: Object
-			 //		the object to "arrayify". We expect the object to have, at a
-			 //		minimum, a length property which corresponds to integer-indexed
-			 //		properties.
-			 // offset: Number?
-			 //		the location in obj to start iterating from. Defaults to 0.
-			 //		Optional.
-			 // startWith: Array?
-			 //		An array to pack with the properties of obj. If provided,
-			 //		properties in obj are appended at the end of startWith and
-			 //		startWith is the returned array.
-		 },
-		 =====*/
-
-		partial: function(/*Function|String*/ method /*, ...*/){
-			// summary:
-			//		similar to hitch() except that the scope object is left to be
-			//		whatever the execution context eventually becomes.
-			// description:
-			//		Calling lang.partial is the functional equivalent of calling:
-			//		|	lang.hitch(null, funcName, ...);
-			// method:
-			//		The function to "wrap"
-			var arr = [ null ];
-			return lang.hitch.apply(dojo, arr.concat(lang._toArray(arguments))); // Function
-		},
-
-		clone: function(/*anything*/ src){
-			// summary:
-			//		Clones objects (including DOM nodes) and all children.
-			//		Warning: do not clone cyclic structures.
-			// src:
-			//		The object to clone
-			if(!src || typeof src != "object" || lang.isFunction(src)){
-				// null, undefined, any non-object, or function
-				return src;	// anything
-			}
-			if(src.nodeType && "cloneNode" in src){
-				// DOM Node
-				return src.cloneNode(true); // Node
-			}
-			if(src instanceof Date){
-				// Date
-				return new Date(src.getTime());	// Date
-			}
-			if(src instanceof RegExp){
-				// RegExp
-				return new RegExp(src);   // RegExp
-			}
-			var r, i, l;
-			if(lang.isArray(src)){
-				// array
-				r = [];
-				for(i = 0, l = src.length; i < l; ++i){
-					if(i in src){
-						r.push(lang.clone(src[i]));
-					}
-				}
-				// we don't clone functions for performance reasons
-				//		}else if(d.isFunction(src)){
-				//			// function
-				//			r = function(){ return src.apply(this, arguments); };
-			}else{
-				// generic objects
-				r = src.constructor ? new src.constructor() : {};
-			}
-			return lang._mixin(r, src, lang.clone);
-		},
-
-
-		trim: String.prototype.trim ?
-			function(str){ return str.trim(); } :
-			function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); },
-		/*=====
-		 trim: function(str){
-			 // summary:
-			 //		Trims whitespace from both sides of the string
-			 // str: String
-			 //		String to be trimmed
-			 // returns: String
-			 //		Returns the trimmed string
-			 // description:
-			 //		This version of trim() was selected for inclusion into the base due
-			 //		to its compact size and relatively good performance
-			 //		(see [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript)
-			 //		Uses String.prototype.trim instead, if available.
-			 //		The fastest but longest version of this function is located at
-			 //		lang.string.trim()
-		 },
-		 =====*/
-
-		replace: function(tmpl, map, pattern){
-			// summary:
-			//		Performs parameterized substitutions on a string. Throws an
-			//		exception if any parameter is unmatched.
-			// tmpl: String
-			//		String to be used as a template.
-			// map: Object|Function
-			//		If an object, it is used as a dictionary to look up substitutions.
-			//		If a function, it is called for every substitution with following parameters:
-			//		a whole match, a name, an offset, and the whole template
-			//		string (see https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace
-			//		for more details).
-			// pattern: RegEx?
-			//		Optional regular expression objects that overrides the default pattern.
-			//		Must be global and match one item. The default is: /\{([^\}]+)\}/g,
-			//		which matches patterns like that: "{xxx}", where "xxx" is any sequence
-			//		of characters, which doesn't include "}".
-			// returns: String
-			//		Returns the substituted string.
-			// example:
-			//	|	// uses a dictionary for substitutions:
-			//	|	lang.replace("Hello, {name.first} {name.last} AKA {nick}!",
-			//	|		{
-			//	|			nick: "Bob",
-			//	|			name: {
-			//	|				first:	"Robert",
-			//	|				middle: "X",
-			//	|				last:		"Cringely"
-			//	|			}
-			//	|		});
-			//	|	// returns: Hello, Robert Cringely AKA Bob!
-			// example:
-			//	|	// uses an array for substitutions:
-			//	|	lang.replace("Hello, {0} {2}!",
-			//	|		["Robert", "X", "Cringely"]);
-			//	|	// returns: Hello, Robert Cringely!
-			// example:
-			//	|	// uses a function for substitutions:
-			//	|	function sum(a){
-			//	|		var t = 0;
-			//	|		arrayforEach(a, function(x){ t += x; });
-			//	|		return t;
-			//	|	}
-			//	|	lang.replace(
-			//	|		"{count} payments averaging {avg} USD per payment.",
-			//	|		lang.hitch(
-			//	|			{ payments: [11, 16, 12] },
-			//	|			function(_, key){
-			//	|				switch(key){
-			//	|					case "count": return this.payments.length;
-			//	|					case "min":		return Math.min.apply(Math, this.payments);
-			//	|					case "max":		return Math.max.apply(Math, this.payments);
-			//	|					case "sum":		return sum(this.payments);
-			//	|					case "avg":		return sum(this.payments) / this.payments.length;
-			//	|				}
-			//	|			}
-			//	|		)
-			//	|	);
-			//	|	// prints: 3 payments averaging 13 USD per payment.
-			// example:
-			//	|	// uses an alternative PHP-like pattern for substitutions:
-			//	|	lang.replace("Hello, ${0} ${2}!",
-			//	|		["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g);
-			//	|	// returns: Hello, Robert Cringely!
-
-			return tmpl.replace(pattern || _pattern, lang.isFunction(map) ?
-				map : function(_, k){ return lang.getObject(k, false, map); });
-		}
-	};
-
-	 1  && lang.mixin(dojo, lang);
-
-	return lang;
-});
-
diff --git a/lib/dojo/_base/loader.js.uncompressed.js b/lib/dojo/_base/loader.js.uncompressed.js
deleted file mode 100644
index 23f0b6db8..000000000
--- a/lib/dojo/_base/loader.js.uncompressed.js
+++ /dev/null
@@ -1,776 +0,0 @@
-define("dojo/_base/loader", ["./kernel", "../has", "require", "module", "./json", "./lang", "./array"], function(dojo, has, require, thisModule, json, lang, array) {
-	// module:
-	//		dojo/_base/loader
-
-	//		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;
-	}
-
-	 1 || has.add("dojo-fast-sync-require", 1);
-
-
-	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 = ( 1  ?
-			// This version of checkDojoRequirePlugin makes the observation that all dojoRequireCallbacks can be released
-			// when all *non-dojo/require!, dojo/loadInit!* modules are either executed, not requested, or arrived. This is
-			// the case since there are no more modules the loader is waiting for, therefore, dojo/require! must have
-			// everything it needs on board.
-			//
-			// The potential weakness of this algorithm is that dojo/require will not execute callbacks until *all* dependency
-			// trees are ready. It is possible that some trees may be ready earlier than others, and this extra wait is non-optimal.
-			// Still, for big projects, this seems better than the original algorithm below that proved slow in some cases.
-			// Note, however, the original algorithm had the potential to execute partial trees,  but that potential was never enabled.
-			// There are also other optimization available with the original algorithm that have not been explored.
-			function(){
-				var module, mid;
-				for(mid in modules){
-					module = modules[mid];
-					if(module.noReqPluginCheck===undefined){
-						// 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.executed && !module.noReqPluginCheck && module.injected==requested){
-						return;
-					}
-				}
-
-				guardCheckComplete(function(){
-					var oldCallbacks = dojoRequireCallbacks;
-					dojoRequireCallbacks = [];
-					array.forEach(oldCallbacks, function(cb){cb(1);});
-				});
-		} : (function(){
-			// Note: this is the original checkDojoRequirePlugin that is much slower than the algorithm above. However, we know it
-			// works, so we leave it here in case the algorithm above fails in some corner case.
-			//
-			// 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
-
-			var 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;
-			};
-
-			return 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];
-					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;
-						}
-					}
-				}
-				guardCheckComplete(function(){
-					var oldCallbacks = dojoRequireCallbacks;
-					dojoRequireCallbacks = [];
-					array.forEach(oldCallbacks, function(cb){cb(1);});
-				});
-			};
-		})()),
-
-		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 map 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,
-						// the list of modules that need to be downloaded but not executed before the callingModule can be executed
-						requireList = [],
-
-						// the list of i18n bundles that are xdomain; undefined if none
-						i18nDeps,
-
-						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 i18nDeps if not already there
-								if(!i18nDeps){
-									// don't have to map since that will occur when the dependency is resolved
-									i18nDeps = ["dojo/i18n"];
-								}
-
-								// figure out if the bundle is xdomain; if so, add it to the i18nDepsSet
-								locale = (locale || dojo.locale).toLowerCase();
-								moduleName = slashName(moduleName) + "/nls/" + (/root/i.test(locale) ? "" : locale + "/") + slashName(bundleName);
-								if(getModule(moduleName, callingModule).isXd){
-									// don't have to map since that will occur when the dependency is resolved
-									i18nDeps.push("dojo/i18n!" + moduleName);
-								}// else the bundle will be loaded synchronously when the module is evaluated
-							},
-							loadInit:function(f){
-								f();
-							}
-						},
-
-						hold = {},
-						p;
-
-					// 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];
-						}
-					}
-
-					if(i18nDeps){
-						requireList = requireList.concat(i18nDeps);
-					}
-
-					if(requireList.length){
-						dojoRequirePlugin(requireList.join(","), require, loaded);
-					}else{
-						loaded();
-					}
-				});
-			});
-		},
-
-		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.
-			//
-			// Notice that this function behaves the same whether or not it happens to be in a mapped dojo/loader module.
-
-			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
-			// don't have to map dojo/init since that will occur when the dependency is resolved
-			return "// xdomain rewrite of " + module.mid + "\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,
-
-		requested =
-			loaderVars.requested,
-
-		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,
-
-		guardCheckComplete =
-			loaderVars.guardCheckComplete;
-
-	// there is exactly one dojoRequirePlugin among possibly-many dojo/_base/loader's (owing to mapping)
-	dojoRequirePlugin = loaderVars.dojoRequirePlugin;
-
-	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);
-
-			// rcg...why here and in two lines??
-			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.guardCheckComplete(function(){
-					execModule(module);
-				});
-			}
-			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 {
-		// summary:
-		//		This module defines the v1.x synchronous loader API.
-
-		extractLegacyApiApplications:extractLegacyApiApplications,
-		require:dojoRequirePlugin,
-		loadInit:dojoLoadInitPlugin
-	};
-});
diff --git a/lib/dojo/_base/query.js.uncompressed.js b/lib/dojo/_base/query.js.uncompressed.js
deleted file mode 100644
index d354bbc6c..000000000
--- a/lib/dojo/_base/query.js.uncompressed.js
+++ /dev/null
@@ -1,13 +0,0 @@
-define("dojo/_base/query", ["../query", "./NodeList"], function(query){
-	// module:
-	//		dojo/_base/query
-
-	/*=====
-	return {
-		// summary:
-		//		Deprecated.   Use dojo/query instead.
-	};
-	=====*/
-
-	return query;
-});
diff --git a/lib/dojo/_base/sniff.js.uncompressed.js b/lib/dojo/_base/sniff.js.uncompressed.js
deleted file mode 100644
index eeb0b8560..000000000
--- a/lib/dojo/_base/sniff.js.uncompressed.js
+++ /dev/null
@@ -1,96 +0,0 @@
-define("dojo/_base/sniff", ["./kernel", "./lang", "../sniff"], function(dojo, lang, has){
-	// module:
-	//		dojo/_base/sniff
-
-	/*=====
-	return {
-		// summary:
-		//		Deprecated.   New code should use dojo/sniff.
-		//		This module populates the dojo browser version sniffing properties like dojo.isIE.
-	};
-	=====*/
-
-	if(! 1 ){
-		return has;
-	}
-
-	// no idea what this is for, or if it's used
-	dojo._name = "browser";
-
-	lang.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: has("ff"),
-
-		// 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: has("ie"),
-
-		// isKhtml: Number|undefined
-		//		Version as a Number if client is a KHTML browser. undefined otherwise. Corresponds to major
-		//		detected version.
-		isKhtml: has("khtml"),
-
-		// isWebKit: Number|undefined
-		//		Version as a Number if client is a WebKit-derived browser (Konqueror,
-		//		Safari, Chrome, etc.). undefined otherwise.
-		isWebKit: has("webkit"),
-
-		// isMozilla: Number|undefined
-		//		Version as a Number if client is a Mozilla-based browser (Firefox,
-		//		SeaMonkey). undefined otherwise. Corresponds to major detected version.
-		isMozilla: has("mozilla"),
-		// isMoz: Number|undefined
-		//		Version as a Number if client is a Mozilla-based browser (Firefox,
-		//		SeaMonkey). undefined otherwise. Corresponds to major detected version.
-		isMoz: has("mozilla"),
-
-		// isOpera: Number|undefined
-		//		Version as a Number if client is Opera. undefined otherwise. Corresponds to
-		//		major detected version.
-		isOpera: has("opera"),
-
-		// isSafari: Number|undefined
-		//		Version as a Number if client is Safari or iPhone. undefined otherwise.
-		isSafari: has("safari"),
-
-		// isChrome: Number|undefined
-		//		Version as a Number if client is Chrome browser. undefined otherwise.
-		isChrome: has("chrome"),
-
-		// isMac: Boolean
-		//		True if the client runs on Mac
-		isMac: has("mac"),
-
-		// isIos: Boolean
-		//		True if client is iPhone, iPod, or iPad
-		isIos: has("ios"),
-
-		// isAndroid: Number|undefined
-		//		Version as a Number if client is android browser. undefined otherwise.
-		isAndroid: has("android"),
-
-		// isWii: Boolean
-		//		True if client is Wii
-		isWii: has("wii"),
-
-		// isQuirks: Boolean
-		//		Page is in quirks mode.
-		isQuirks: has("quirks"),
-
-		// isAir: Boolean
-		//		True if client is Adobe Air
-		isAir: has("air")
-	});
-
-
-	dojo.locale = dojo.locale || (has("ie") ? navigator.userLanguage : navigator.language).toLowerCase();
-
-	return has;
-});
diff --git a/lib/dojo/_base/unload.js.uncompressed.js b/lib/dojo/_base/unload.js.uncompressed.js
deleted file mode 100644
index 1ceae7d29..000000000
--- a/lib/dojo/_base/unload.js.uncompressed.js
+++ /dev/null
@@ -1,82 +0,0 @@
-define("dojo/_base/unload", ["./kernel", "./lang", "../on"], function(dojo, lang, on){
-
-// module:
-//		dojo/unload
-
-var win = window;
-
-var unload = {
-	// summary:
-	//		This module contains the document and window unload detection API.
-
-	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
-		//		destroy "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
-		//		addOnUnload() if you need to modify the DOM or do
-		//		heavy JavaScript work since it fires at the equivalent of
-		//		the page's "onbeforeunload" event.
-		// example:
-		//	|	unload.addOnWindowUnload(functionPointer)
-		//	|	unload.addOnWindowUnload(object, "functionName");
-		//	|	unload.addOnWindowUnload(object, function(){ /* ... */});
-
-		if (!dojo.windowUnloaded){
-			on(win, "unload", (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
-				//		addOnWindowUnload(). This behavior started in Dojo 1.3.
-				//		Previous versions always triggered windowUnloaded(). See
-				//		addOnWindowUnload for more info.
-			}));
-		}
-		on(win, "unload", lang.hitch(obj, functionName));
-	},
-
-	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 environment, 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(){ /* ... */});
-
-		on(win, "beforeunload", lang.hitch(obj, functionName));
-	}
-};
-
-dojo.addOnWindowUnload = unload.addOnWindowUnload;
-dojo.addOnUnload = unload.addOnUnload;
-
-return unload;
-
-});
diff --git a/lib/dojo/_base/url.js.uncompressed.js b/lib/dojo/_base/url.js.uncompressed.js
deleted file mode 100644
index c83e1a2e3..000000000
--- a/lib/dojo/_base/url.js.uncompressed.js
+++ /dev/null
@@ -1,109 +0,0 @@
-define("dojo/_base/url", ["./kernel"], function(dojo){
-	// module:
-	//		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.uncompressed.js b/lib/dojo/_base/window.js.uncompressed.js
deleted file mode 100644
index 3d23c3a97..000000000
--- a/lib/dojo/_base/window.js.uncompressed.js
+++ /dev/null
@@ -1,134 +0,0 @@
-define("dojo/_base/window", ["./kernel", "./lang", "../sniff"], function(dojo, lang, has){
-// module:
-//		dojo/_base/window
-
-var ret = {
-	// summary:
-	//		API to save/set/restore the global/document scope.
-
-	global: dojo.global,
-	/*=====
-	 global: {
-		 // summary:
-		 //		Alias for the current window. 'global' can be modified
-		 //		for temporary context shifting. See also withGlobal().
-		 // description:
-		 //		Use this rather than referring to 'window' to ensure your code runs
-		 //		correctly in managed contexts.
-	 },
-	 =====*/
-
-	doc: this["document"] || null,
-	/*=====
-	doc: {
-		// summary:
-		//		Alias for the current document. 'doc' can be modified
-		//		for temporary context shifting. See also withDoc().
-		// description:
-		//		Use this rather than referring to 'window.document' to ensure your code runs
-		//		correctly in managed contexts.
-		// example:
-		//	|	n.appendChild(dojo.doc.createElement('div'));
-	},
-	=====*/
-
-	body: function(/*Document?*/ doc){
-		// summary:
-		//		Return the body element of the specified document or of dojo/_base/window::doc.
-		// example:
-		//	|	win.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().
-		doc = doc || dojo.doc;
-		return doc.body || doc.getElementsByTagName("body")[0]; // Node
-	},
-
-	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;
-	},
-
-	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 ret.withDoc.call(null, globalObject.document, callback, thisObject, cbArguments);
-		}finally{
-			dojo.global = ret.global = oldGlob;
-		}
-	},
-
-	withDoc: function(	/*DocumentElement*/ documentObject,
-						/*Function*/ callback,
-						/*Object?*/ thisObject,
-						/*Array?*/ cbArguments){
-		// summary:
-		//		Invoke callback with documentObject as dojo/_base/window::doc.
-		// description:
-		//		Invoke callback with documentObject as dojo/_base/window::doc. If provided,
-		//		callback will be executed in the context of object thisObject
-		//		When callback() returns or throws an error, the dojo/_base/window::doc will
-		//		be restored to its previous state.
-
-		var oldDoc = ret.doc,
-			oldQ = has("quirks"),
-			oldIE = has("ie"), isIE, mode, pwin;
-
-		try{
-			dojo.doc = ret.doc = documentObject;
-			// update dojo.isQuirks and the value of the has feature "quirks".
-			// remove setting dojo.isQuirks and dojo.isIE for 2.0
-			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);
-		}
-	}
-};
-
- 1  && lang.mixin(dojo, ret);
-
-return ret;
-
-});
diff --git a/lib/dojo/_base/xhr.js.uncompressed.js b/lib/dojo/_base/xhr.js.uncompressed.js
deleted file mode 100644
index ee78af504..000000000
--- a/lib/dojo/_base/xhr.js.uncompressed.js
+++ /dev/null
@@ -1,710 +0,0 @@
-define("dojo/_base/xhr", [
-	"./kernel",
-	"./sniff",
-	"require",
-	"../io-query",
-	/*===== "./declare", =====*/
-	"../dom",
-	"../dom-form",
-	"./Deferred",
-	"./config",
-	"./json",
-	"./lang",
-	"./array",
-	"../on",
-	"../aspect",
-	"../request/watch",
-	"../request/xhr",
-	"../request/util"
-], function(dojo, has, require, ioq, /*===== declare, =====*/ dom, domForm, Deferred, config, json, lang, array, on, aspect, watch, _xhr, util){
-	// module:
-	//		dojo/_base/xhr
-
-	/*=====
-	dojo._xhrObj = function(){
-		// summary:
-		//		does the work of portably generating a new XMLHTTPRequest object.
-	};
-	=====*/
-	dojo._xhrObj = _xhr._create;
-
-	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 available XHR transport handle types. Name matches the
-		//		`handleAs` attribute passed to XHR calls.
-		// description:
-		//		A map of available 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:
-		//	|	xhr.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(!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);
-			}
-		}
-	};
-
-	/*=====
-
-	// kwargs function parameter definitions.   Assigning to dojo namespace rather than making them local variables
-	// because they are used by dojo/io modules too
-
-	dojo.__IoArgs = declare(null, {
-		// 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/_base/xhr.rawXhrPost and dojo/_base/xhr.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/topic.publish() for different phases of an IO operation.
-		//		See dojo/main.__IoPublish for a list of topics that are published.
-
-		load: function(response, ioArgs){
-			// summary:
-			//		This function will be
-			//		called on a successful HTTP response code.
-	 		// ioArgs: dojo/main.__IoCallbackArgs
-			//		Provides additional information about the request.
-			// response: Object
-			//		The response in the format as defined with handleAs.
-		},
-
-		error: function(response, ioArgs){
-			// summary:
-			//		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.
-			// ioArgs: dojo/main.__IoCallbackArgs
-			//		Provides additional information about the request.
-			// response: Object
-			//		The response in the format as defined with handleAs.
-		},
-
-		handle: function(loadOrError, response, ioArgs){
-			// summary:
-	 		//		This function will
-	 		//		be called at the end of every request, whether or not an error occurs.
-			// 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/main.__IoCallbackArgs
-			//		Provides additional information about the request.
-		}
-	});
-
-	dojo.__IoCallbackArgs = declare(null, {
-		// 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.
-	});
-
-	dojo.__IoPublish = declare(null, {
-		// 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.
-	});
-	=====*/
-
-
-	dojo._ioSetArgs = function(/*dojo/main.__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 requested.
-		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(function(dfd){
-			dfd.canceled = true;
-			canceller && canceller(dfd);
-
-			var err = dfd.ioArgs.error;
-			if(!err){
-				err = new Error("request cancelled");
-				err.dojoType="cancel";
-				dfd.ioArgs.error = err;
-			}
-			return err;
-		});
-		d.addCallback(okHandler);
-
-		//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);
-			});
-		}
-
-		// Attach error handler last (not including topic publishing)
-		// to catch any errors that may have been generated from load
-		// or handle functions.
-		d.addErrback(function(error){
-			return errHandler(error, d);
-		});
-
-		//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
-		// analogous in the Deferred
-		return d;
-	};
-
-	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;
-	};
-
-	//Use a separate count for knowing if we are starting/stopping io calls.
-	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 _pubCount = 0;
-	aspect.after(watch, "_onAction", function(){
-		_pubCount -= 1;
-	});
-	aspect.after(watch, "_onInFlight", _checkPubCount);
-
-	dojo._ioCancelAll = watch.cancelAll;
-	/*=====
-	dojo._ioCancelAll = function(){
-		// summary:
-		//		Cancels all pending IO requests, regardless of IO type
-		//		(xhr, script, iframe).
-	};
-	=====*/
-
-	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.
-		//
-		//		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.options = dfd.ioArgs.args;
-		lang.mixin(dfd, {
-			response: dfd.ioArgs,
-			isValid: function(response){
-				return validCheck(dfd);
-			},
-			isReady: function(response){
-				return ioCheck(dfd);
-			},
-			handleResponse: function(response){
-				return resHandle(dfd);
-			}
-		});
-		watch(dfd);
-
-		_checkPubCount(dfd);
-	};
-
-	var _defaultContentType = "application/x-www-form-urlencoded";
-
-	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.__XhrArgs = declare(dojo.__IoArgs, {
-		// 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/_base/xhr.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.
-	 });
-	=====*/
-
-	dojo.xhr = function(/*String*/ method, /*dojo.__XhrArgs*/ args, /*Boolean?*/ hasBody){
-		// summary:
-		//		Deprecated.   Use dojo/request instead.
-		// 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.
-
-		var rDfd;
-		//Make the Deferred object for this xhr request.
-		var dfd = dojo._ioSetArgs(args, function(dfd){
-			rDfd && rDfd.cancel();
-		}, _deferredOk, _deferError);
-		var ioArgs = dfd.ioArgs;
-
-		//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);
-		}
-
-		var options = {
-			method: method,
-			handleAs: "text",
-			timeout: args.timeout,
-			withCredentials: args.withCredentials,
-			ioArgs: ioArgs
-		};
-
-		if(typeof args.headers !== 'undefined'){
-			options.headers = args.headers;
-		}
-		if(typeof args.contentType !== 'undefined'){
-			if(!options.headers){
-				options.headers = {};
-			}
-			options.headers['Content-Type'] = args.contentType;
-		}
-		if(typeof ioArgs.query !== 'undefined'){
-			options.data = ioArgs.query;
-		}
-		if(typeof args.sync !== 'undefined'){
-			options.sync = args.sync;
-		}
-
-		dojo._ioNotifyStart(dfd);
-		try{
-			rDfd = _xhr(ioArgs.url, options, true);
-		}catch(e){
-			// If XHR creation fails, dojo/request/xhr throws
-			// When this happens, cancel the deferred
-			dfd.cancel();
-			return dfd;
-		}
-
-		// sync ioArgs
-		dfd.ioArgs.xhr = rDfd.response.xhr;
-
-		rDfd.then(function(){
-			dfd.resolve(dfd);
-		}).otherwise(function(error){
-			ioArgs.error = error;
-			if(error.response){
-				error.status = error.response.status;
-				error.responseText = error.response.text;
-				error.xhr = error.response.xhr;
-			}
-			dfd.reject(error);
-		});
-		return dfd; // dojo/_base/Deferred
-	};
-
-	dojo.xhrGet = function(/*dojo.__XhrArgs*/ args){
-		// summary:
-		//		Sends an HTTP GET request to the server.
-		return dojo.xhr("GET", args); // dojo/_base/Deferred
-	};
-
-	dojo.rawXhrPost = dojo.xhrPost = function(/*dojo.__XhrArgs*/ args){
-		// summary:
-		//		Sends an HTTP POST request to the server. In addition 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/_base/Deferred
-	};
-
-	dojo.rawXhrPut = dojo.xhrPut = function(/*dojo.__XhrArgs*/ args){
-		// summary:
-		//		Sends an HTTP PUT request to the server. In addition 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/_base/Deferred
-	};
-
-	dojo.xhrDelete = function(/*dojo.__XhrArgs*/ args){
-		// summary:
-		//		Sends an HTTP DELETE request to the server.
-		return dojo.xhr("DELETE", args); // dojo/_base/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(x){
-		return util.checkStatus(x.status);
-	};
-
-	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;
-});