dojo-rails 0.9.9 → 0.9.10

data/vendor/assets/javascripts/dojo/promise/instrumentation.js.uncompressed.js

@@ -0,0 +1,103 @@
+define("dojo/promise/instrumentation", [
+	"./tracer",
+	"../has",
+	"../_base/lang",
+	"../_base/array"
+], function(tracer, has, lang, arrayUtil){
+	function logError(error, rejection, deferred){
+		var stack = "";
+		if(error && error.stack){
+			stack += error.stack;
+		}
+		if(rejection && rejection.stack){
+			stack += "\n    ----------------------------------------\n    rejected" + rejection.stack.split("\n").slice(1).join("\n").replace(/^\s+/, " ");
+		}
+		if(deferred && deferred.stack){
+			stack += "\n    ----------------------------------------\n" + deferred.stack;
+		}
+		console.error(error, stack);
+	}
+
+	function reportRejections(error, handled, rejection, deferred){
+		if(!handled){
+			logError(error, rejection, deferred);
+		}
+	}
+
+	var errors = [];
+	var activeTimeout = false;
+	var unhandledWait = 1000;
+	function trackUnhandledRejections(error, handled, rejection, deferred){
+		if(handled){
+			arrayUtil.some(errors, function(obj, ix){
+				if(obj.error === error){
+					errors.splice(ix, 1);
+					return true;
+				}
+			});
+		}else if(!arrayUtil.some(errors, function(obj){ return obj.error === error; })){
+			errors.push({
+				error: error,
+				rejection: rejection,
+				deferred: deferred,
+				timestamp: new Date().getTime()
+			});
+		}
+
+		if(!activeTimeout){
+			activeTimeout = setTimeout(logRejected, unhandledWait);
+		}
+	}
+
+	function logRejected(){
+		var now = new Date().getTime();
+		var reportBefore = now - unhandledWait;
+		errors = arrayUtil.filter(errors, function(obj){
+			if(obj.timestamp < reportBefore){
+				logError(obj.error, obj.rejection, obj.deferred);
+				return false;
+			}
+			return true;
+		});
+
+		if(errors.length){
+			activeTimeout = setTimeout(logRejected, errors[0].timestamp + unhandledWait - now);
+		}
+	}
+
+	return function(Deferred){
+		// summary:
+		//		Initialize instrumentation for the Deferred class.
+		// description:
+		//		Initialize instrumentation for the Deferred class.
+		//		Done automatically by `dojo/Deferred` if the
+		//		`deferredInstrumentation` and `useDeferredInstrumentation`
+		//		config options are set.
+		//
+		//		Sets up `dojo/promise/tracer` to log to the console.
+		//
+		//		Sets up instrumentation of rejected deferreds so unhandled
+		//		errors are logged to the console.
+
+		var usage = has("config-useDeferredInstrumentation");
+		if(usage){
+			tracer.on("resolved", lang.hitch(console, "log", "resolved"));
+			tracer.on("rejected", lang.hitch(console, "log", "rejected"));
+			tracer.on("progress", lang.hitch(console, "log", "progress"));
+
+			var args = [];
+			if(typeof usage === "string"){
+				args = usage.split(",");
+				usage = args.shift();
+			}
+			if(usage === "report-rejections"){
+				Deferred.instrumentRejected = reportRejections;
+			}else if(usage === "report-unhandled-rejections" || usage === true || usage === 1){
+				Deferred.instrumentRejected = trackUnhandledRejections;
+				unhandledWait = parseInt(args[0], 10) || unhandledWait;
+			}else{
+				throw new Error("Unsupported instrumentation usage <" + usage + ">");
+			}
+		}
+	};
+});

data/vendor/assets/javascripts/dojo/promise/tracer.js

@@ -0,0 +1,37 @@
+/*
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
+	Available via Academic Free License >= 2.1 OR the modified BSD license.
+	see: http://dojotoolkit.org/license for details
+*/
+
+//>>built
+define("dojo/promise/tracer",["../_base/lang","./Promise","../Evented"],function(_1,_2,_3){
+"use strict";
+var _4=new _3;
+var _5=_4.emit;
+_4.emit=null;
+function _6(_7){
+setTimeout(function(){
+_5.apply(_4,_7);
+},0);
+};
+_2.prototype.trace=function(){
+var _8=_1._toArray(arguments);
+this.then(function(_9){
+_6(["resolved",_9].concat(_8));
+},function(_a){
+_6(["rejected",_a].concat(_8));
+},function(_b){
+_6(["progress",_b].concat(_8));
+});
+return this;
+};
+_2.prototype.traceRejected=function(){
+var _c=_1._toArray(arguments);
+this.otherwise(function(_d){
+_6(["rejected",_d].concat(_c));
+});
+return this;
+};
+return _4;
+});

data/vendor/assets/javascripts/dojo/promise/tracer.js.uncompressed.js

@@ -0,0 +1,85 @@
+define("dojo/promise/tracer", [
+	"../_base/lang",
+	"./Promise",
+	"../Evented"
+], function(lang, Promise, Evented){
+	"use strict";
+
+	// module:
+	//		dojo/promise/tracer
+
+	/*=====
+	return {
+		// summary:
+		//		Trace promise fulfillment.
+		// description:
+		//		Trace promise fulfillment. Calling `.trace()` or `.traceError()` on a
+		//		promise enables tracing. Will emit `resolved`, `rejected` or `progress`
+		//		events.
+
+		on: function(type, listener){
+			// summary:
+			//		Subscribe to traces.
+			// description:
+			//		See `dojo/Evented#on()`.
+			// type: String
+			//		`resolved`, `rejected`, or `progress`
+			// listener: Function
+			//		The listener is passed the traced value and any arguments
+			//		that were used with the `.trace()` call.
+		}
+	};
+	=====*/
+
+	var evented = new Evented;
+	var emit = evented.emit;
+	evented.emit = null;
+	// Emit events asynchronously since they should not change the promise state.
+	function emitAsync(args){
+		setTimeout(function(){
+			emit.apply(evented, args);
+		}, 0);
+	}
+
+	Promise.prototype.trace = function(){
+		// summary:
+		//		Trace the promise.
+		// description:
+		//		Tracing allows you to transparently log progress,
+		//		resolution and rejection of promises, without affecting the
+		//		promise itself. Any arguments passed to `trace()` are
+		//		emitted in trace events. See `dojo/promise/tracer` on how
+		//		to handle traces.
+		// returns: dojo/promise/Promise
+		//		The promise instance `trace()` is called on.
+
+		var args = lang._toArray(arguments);
+		this.then(
+			function(value){ emitAsync(["resolved", value].concat(args)); },
+			function(error){ emitAsync(["rejected", error].concat(args)); },
+			function(update){ emitAsync(["progress", update].concat(args)); }
+		);
+		return this;
+	};
+
+	Promise.prototype.traceRejected = function(){
+		// summary:
+		//		Trace rejection of the promise.
+		// description:
+		//		Tracing allows you to transparently log progress,
+		//		resolution and rejection of promises, without affecting the
+		//		promise itself. Any arguments passed to `trace()` are
+		//		emitted in trace events. See `dojo/promise/tracer` on how
+		//		to handle traces.
+		// returns: dojo/promise/Promise
+		//		The promise instance `traceRejected()` is called on.
+
+		var args = lang._toArray(arguments);
+		this.otherwise(function(error){
+			emitAsync(["rejected", error].concat(args));
+		});
+		return this;
+	};
+
+	return evented;
+});

data/vendor/assets/javascripts/dojo/query.js

@@ -111,8 +111,8 @@ return this._parent;
 return new this._NodeListCtor(0);
 }
 },concat:function(_23){
-var t=_5.isArray(this)?this:_8.call(this,0),m=_4.map(arguments,function(a){
-return a&&!_5.isArray(a)&&(typeof _16!="undefined"&&a.constructor===_16||a.constructor===this._NodeListCtor)?_8.call(a,0):a;
+var t=_8.call(this,0),m=_4.map(arguments,function(a){
+return _8.call(a,0);
 });
 return this._wrap(_9.apply(t,m),this);
 },map:function(_24,obj){
@@ -156,7 +156,7 @@ if(!_33){
 return new _30([]);
 }
 }
-var _34=typeof _32=="string"?_2f(_32,_33):_32.orphan?_32:[_32];
+var _34=typeof _32=="string"?_2f(_32,_33):_32?_32.orphan?_32:[_32]:[];
 if(_34.orphan){
 return _34;
 }
@@ -182,13 +182,13 @@ var _2a=_2e(_7,_16);
 _1.query=_2e(_7,function(_3f){
 return _16(_3f);
 });
-_2a.load=function(id,_40,_41,_42){
-_6.load(id,_40,function(_43){
-_41(_2e(_43,_16));
+_2a.load=function(id,_40,_41){
+_6.load(id,_40,function(_42){
+_41(_2e(_42,_16));
 });
 };
-_1._filterQueryResult=_2a._filterResult=function(_44,_45,_46){
-return new _16(_2a.filter(_44,_45,_46));
+_1._filterQueryResult=_2a._filterResult=function(_43,_44,_45){
+return new _16(_2a.filter(_43,_44,_45));
 };
 _1.NodeList=_2a.NodeList=_16;
 return _2a;

data/vendor/assets/javascripts/dojo/query.js.uncompressed.js

@@ -1,6 +1,7 @@
 define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array", "./_base/lang", "./selector/_loader", "./selector/_loader!default"],
 	function(dojo, has, dom, on, array, lang, loader, defaultEngine){
-"use strict";
+
+	"use strict";
 
 	has.add("array-extensible", function(){
 		// test to see if we can extend an array (not supported in old IE)
@@ -9,9 +10,9 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 	
 	var ap = Array.prototype, aps = ap.slice, apc = ap.concat, forEach = array.forEach;
 
-	var tnl = function(/*Array*/ a, /*dojo.NodeList?*/ parent, /*Function?*/ NodeListCtor){
+	var tnl = function(/*Array*/ a, /*dojo/NodeList?*/ parent, /*Function?*/ NodeListCtor){
 		// summary:
-		//		decorate an array to make it look like a `dojo.NodeList`.
+		//		decorate an array to make it look like a `dojo/NodeList`.
 		// a:
 		//		Array of nodes to decorate.
 		// parent:
@@ -21,7 +22,7 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 		// NodeListCtor:
 		//		An optional constructor function to use for any
 		//		new NodeList calls. This allows a certain chain of
-		//		NodeList calls to use a different object than dojo.NodeList.
+		//		NodeList calls to use a different object than dojo/NodeList.
 		var nodeList = new (NodeListCtor || this._NodeListCtor || nl)(a);
 		return parent ? nodeList._stash(parent) : nodeList;
 	};
@@ -99,12 +100,12 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 
 	var NodeList = function(array){
 		// summary:
-		//		dojo.NodeList is an of Array-like object which adds syntactic
+		//		Array-like object which adds syntactic
 		//		sugar for chaining, common iteration operations, animation, and
 		//		node manipulation. NodeLists are most often returned as the
 		//		result of dojo.query() calls.
 		// description:
-		//		dojo.NodeList instances provide many utilities that reflect
+		//		NodeList instances provide many utilities that reflect
 		//		core Dojo APIs for Array iteration and manipulation, DOM
 		//		manipulation, and event handling. Instead of needing to dig up
 		//		functions in the dojo.* namespace, NodeLists generally make the
@@ -112,7 +113,7 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 		//		simple, chainable way.
 		// example:
 		//		create a node list from a node
-		//		|	new dojo.NodeList(dojo.byId("foo"));
+		//		|	new query.NodeList(dojo.byId("foo"));
 		// example:
 		//		get a NodeList from a CSS query and iterate on it
 		//		|	var l = dojo.query(".thinger");
@@ -149,8 +150,7 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 		//		|	// even getting the coordinates of all the items
 		//		|	var coords = dojo.query(".thinger").coords();
 		// example:
-		//		DOM manipulation functions from the dojo.* namespace area also
-		//		available:
+		//		DOM manipulation functions from the dojo.* namespace area also available:
 		//		|	// remove all of the elements in the list from their
 		//		|	// parents (akin to "deleting" them from the document)
 		//		|	dojo.query(".thinger").orphan();
@@ -235,7 +235,6 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 		nlp[name] = function(){ return f.apply(dojo, [this].concat(aps.call(arguments, 0))); };
 	});
 
-	/*===== var NodeList = dojo.NodeList; =====*/
 	lang.extend(NodeList, {
 		// copy the constructors
 		constructor: nl,
@@ -249,11 +248,11 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 			//		private function to hold to a parent NodeList. end() to return the parent NodeList.
 			//
 			// example:
-			// How to make a `dojo.NodeList` method that only returns the third node in
-			// the dojo.NodeList but allows access to the original NodeList by using this._stash:
-			//	|	dojo.extend(dojo.NodeList, {
+			//		How to make a `dojo/NodeList` method that only returns the third node in
+			//		the dojo/NodeList but allows access to the original NodeList by using this._stash:
+			//	|	dojo.extend(NodeList, {
 			//	|		third: function(){
-			//	|			var newNodeList = dojo.NodeList(this[2]);
+			//	|			var newNodeList = NodeList(this[2]);
 			//	|			return newNodeList._stash(this);
 			//	|		}
 			//	|	});
@@ -267,17 +266,17 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 			//	|
 			//
 			this._parent = parent;
-			return this; //dojo.NodeList
+			return this; // dojo/NodeList
 		},
 
 		on: function(eventName, listener){
 			// summary:
 			//		Listen for events on the nodes in the NodeList. Basic usage is:
 			//		| query(".my-class").on("click", listener);
-			// 		This supports event delegation by using selectors as the first argument with the event names as
+			//		This supports event delegation by using selectors as the first argument with the event names as
 			//		pseudo selectors. For example:
 			//		| dojo.query("#my-list").on("li:click", listener);
-			//		This will listen for click events within <li> elements that are inside the #my-list element.
+			//		This will listen for click events within `<li>` elements that are inside the `#my-list` element.
 			//		Because on supports CSS selector syntax, we can use comma-delimited events as well:
 			//		| dojo.query("#my-list").on("li button:mouseover, li:click", listener);
 			var handles = this.map(function(node){
@@ -293,11 +292,11 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 
 		end: function(){
 			// summary:
-			//		Ends use of the current `dojo.NodeList` by returning the previous dojo.NodeList
-			//		that generated the current dojo.NodeList.
+			//		Ends use of the current `NodeList` by returning the previous NodeList
+			//		that generated the current NodeList.
 			// description:
-			//		Returns the `dojo.NodeList` that generated the current `dojo.NodeList`. If there
-			//		is no parent dojo.NodeList, an empty dojo.NodeList is returned.
+			//		Returns the `NodeList` that generated the current `NodeList`. If there
+			//		is no parent NodeList, an empty NodeList is returned.
 			// example:
 			//	|	dojo.query("a")
 			//	|		.filter(".disabled")
@@ -332,9 +331,9 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 			//		Returns a new NodeList, maintaining this one in place
 			// description:
 			//		This method behaves exactly like the Array.slice method
-			//		with the caveat that it returns a dojo.NodeList and not a
-			//		raw Array. For more details, see Mozilla's (slice
-			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:slice]
+			//		with the caveat that it returns a dojo/NodeList and not a
+			//		raw Array. For more details, see Mozilla's [slice
+			//		documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/slice)
 			// begin: Integer
 			//		Can be a positive or negative integer, with positive
 			//		integers noting the offset to begin at, and negative
@@ -354,9 +353,9 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 			//		at an offset, optionally deleting elements
 			// description:
 			//		This method behaves exactly like the Array.splice method
-			//		with the caveat that it returns a dojo.NodeList and not a
-			//		raw Array. For more details, see Mozilla's (splice
-			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:splice]
+			//		with the caveat that it returns a dojo/NodeList and not a
+			//		raw Array. For more details, see Mozilla's [splice
+			//		documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice)
 			//		For backwards compatibility, calling .end() on the spliced NodeList
 			//		does not return the original NodeList -- splice alters the NodeList in place.
 			// index: Integer
@@ -371,23 +370,21 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 			// item: Object...?
 			//		Any number of optional parameters may be passed in to be
 			//		spliced into the NodeList
-			// returns:
-			//		dojo.NodeList
-			return this._wrap(a.splice.apply(this, arguments));
+			return this._wrap(a.splice.apply(this, arguments));	// dojo/NodeList
 		},
 
 		indexOf: function(value, fromIndex){
 			// summary:
 			//		see dojo.indexOf(). The primary difference is that the acted-on
 			//		array is implicitly this NodeList
-			// value: Object:
+			// value: Object
 			//		The value to search for.
-			// fromIndex: Integer?:
+			// fromIndex: Integer?
 			//		The location to start searching from. Optional. Defaults to 0.
 			// description:
 			//		For more details on the behavior of indexOf, see Mozilla's
-			//		(indexOf
-			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:indexOf]
+			//		[indexOf
+			//		docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf)
 			// returns:
 			//		Positive Integer or 0 for a match, -1 of not found.
 			return d.indexOf(this, value, fromIndex); // Integer
@@ -399,8 +396,8 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 			//		acted-on array is implicitly this NodeList
 			// description:
 			//		For more details on the behavior of lastIndexOf, see
-			//		Mozilla's (lastIndexOf
-			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:lastIndexOf]
+			//		Mozilla's [lastIndexOf
+			//		docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/lastIndexOf)
 			// value: Object
 			//		The value to search for.
 			// fromIndex: Integer?
@@ -412,13 +409,15 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 
 		every: function(callback, thisObject){
 			// summary:
-			//		see `dojo.every()` and the (Array.every
-			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:every].
+			//		see `dojo.every()` and the [Array.every
+			//		docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every).
 			//		Takes the same structure of arguments and returns as
 			//		dojo.every() with the caveat that the passed array is
 			//		implicitly this NodeList
-			// callback: Function: the callback
-			// thisObject: Object?: the context
+			// callback: Function
+			//		the callback
+			// thisObject: Object?
+			//		the context
 			return d.every(this, callback, thisObject); // Boolean
 		},
 
@@ -427,10 +426,12 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 			//		Takes the same structure of arguments and returns as
 			//		`dojo.some()` with the caveat that the passed array is
 			//		implicitly this NodeList.  See `dojo.some()` and Mozilla's
-			//		(Array.some
-			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some].
-			// callback: Function: the callback
-			// thisObject: Object?: the context
+			//		[Array.some
+			//		documentation](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some).
+			// callback: Function
+			//		the callback
+			// thisObject: Object?
+			//		the context
 			return d.some(this, callback, thisObject); // Boolean
 		},
 		=====*/
@@ -441,43 +442,36 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 			//		as well as items passed in as parameters
 			// description:
 			//		This method behaves exactly like the Array.concat method
-			//		with the caveat that it returns a `dojo.NodeList` and not a
-			//		raw Array. For more details, see the (Array.concat
-			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:concat]
+			//		with the caveat that it returns a `NodeList` and not a
+			//		raw Array. For more details, see the [Array.concat
+			//		docs](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/concat)
 			// item: Object?
 			//		Any number of optional parameters may be passed in to be
 			//		spliced into the NodeList
-			// returns:
-			//		dojo.NodeList
 
 			//return this._wrap(apc.apply(this, arguments));
-			// the line above won't work for the native NodeList :-(
+			// the line above won't work for the native NodeList, or for Dojo NodeLists either :-(
 
 			// implementation notes:
-			// 1) Native NodeList is not an array, and cannot be used directly
-			// in concat() --- the latter doesn't recognize it as an array, and
-			// does not inline it, but append as a single entity.
-			// 2) On some browsers (e.g., Safari) the "constructor" property is
-			// read-only and cannot be changed. So we have to test for both
-			// native NodeList and dojo.NodeList in this property to recognize
-			// the node list.
-
-			var t = lang.isArray(this) ? this : aps.call(this, 0),
+			// Array.concat() doesn't recognize native NodeLists or Dojo NodeLists
+			// as arrays, and so does not inline them into a unioned array, but
+			// appends them as single entities. Both the original NodeList and the
+			// items passed in as parameters must be converted to raw Arrays
+			// and then the concatenation result may be re-_wrap()ed as a Dojo NodeList.
+
+			var t = aps.call(this, 0),
 				m = array.map(arguments, function(a){
-					return a && !lang.isArray(a) &&
-						(typeof NodeList != "undefined" && a.constructor === NodeList || a.constructor === this._NodeListCtor) ?
-							aps.call(a, 0) : a;
+					return aps.call(a, 0);
 				});
-			return this._wrap(apc.apply(t, m), this);	// dojo.NodeList
+			return this._wrap(apc.apply(t, m), this);	// dojo/NodeList
 		},
 
 		map: function(/*Function*/ func, /*Function?*/ obj){
 			// summary:
 			//		see dojo.map(). The primary difference is that the acted-on
 			//		array is implicitly this NodeList and the return is a
-			//		dojo.NodeList (a subclass of Array)
-			///return d.map(this, func, obj, d.NodeList); // dojo.NodeList
-			return this._wrap(array.map(this, func, obj), this); // dojo.NodeList
+			//		NodeList (a subclass of Array)
+			return this._wrap(array.map(this, func, obj), this); // dojo/NodeList
 		},
 
 		forEach: function(callback, thisObj){
@@ -487,7 +481,7 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 			//		of the forEach loop, use every() or some() instead.
 			forEach(this, callback, thisObj);
 			// non-standard return to allow easier chaining
-			return this; // dojo.NodeList
+			return this; // dojo/NodeList
 		},
 		filter: function(/*String|Function*/ filter){
 			// summary:
@@ -512,26 +506,26 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 				items = query._filterResult(this, a[0]);
 				if(a.length == 1){
 					// if we only got a string query, pass back the filtered results
-					return items._stash(this); // dojo.NodeList
+					return items._stash(this); // dojo/NodeList
 				}
 				// if we got a callback, run it over the filtered items
 				start = 1;
 			}
-			return this._wrap(array.filter(items, a[start], a[start + 1]), this);	// dojo.NodeList
+			return this._wrap(array.filter(items, a[start], a[start + 1]), this);	// dojo/NodeList
 		},
 		instantiate: function(/*String|Object*/ declaredClass, /*Object?*/ properties){
 			// summary:
 			//		Create a new instance of a specified class, using the
-			//		specified properties and each node in the nodeList as a
+			//		specified properties and each node in the NodeList as a
 			//		srcNodeRef.
 			// example:
-			//		Grabs all buttons in the page and converts them to diji.form.Buttons.
-			//	|	var buttons = dojo.query("button").instantiate("dijit.form.Button", {showLabel: true});
+			//		Grabs all buttons in the page and converts them to dijit/form/Button's.
+			//	|	var buttons = query("button").instantiate(Button, {showLabel: true});
 			var c = lang.isFunction(declaredClass) ? declaredClass : lang.getObject(declaredClass);
 			properties = properties || {};
 			return this.forEach(function(node){
 				new c(properties, node);
-			});	// dojo.NodeList
+			});	// dojo/NodeList
 		},
 		at: function(/*===== index =====*/){
 			// summary:
@@ -545,169 +539,167 @@ define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array
 			//
 			// example:
 			//	Shorten the list to the first, second, and third elements
-			//	|	dojo.query("a").at(0, 1, 2).forEach(fn);
+			//	|	query("a").at(0, 1, 2).forEach(fn);
 			//
 			// example:
 			//	Retrieve the first and last elements of a unordered list:
-			//	|	dojo.query("ul > li").at(0, -1).forEach(cb);
+			//	|	query("ul > li").at(0, -1).forEach(cb);
 			//
 			// example:
 			//	Do something for the first element only, but end() out back to
 			//	the original list and continue chaining:
-			//	|	dojo.query("a").at(0).onclick(fn).end().forEach(function(n){
+			//	|	query("a").at(0).onclick(fn).end().forEach(function(n){
 			//	|		console.log(n); // all anchors on the page.
 			//	|	})
-			//
-			// returns:
-			//		dojo.NodeList
+
 			var t = new this._NodeListCtor(0);
 			forEach(arguments, function(i){
 				if(i < 0){ i = this.length + i; }
 				if(this[i]){ t.push(this[i]); }
 			}, this);
-			return t._stash(this); // dojo.NodeList
+			return t._stash(this); // dojo/NodeList
 		}
 	});
 
-
-/*===== 
-dojo.query = function(selector, context){
-	// summary:
-	//		This modules provides DOM querying functionality. The module export is a function
-	//		that can be used to query for DOM nodes by CSS selector and returns a dojo.NodeList
-	//		representing the matching nodes.
-	//
-	// selector: String
-	//		A CSS selector to search for.
-	// context: String|DomNode?
-	//		An optional context to limit the searching scope. Only nodes under `context` will be 
-	//		scanned. 
-	// 
-	//	example:
-	//		add an onclick handler to every submit button in the document
-	//		which causes the form to be sent via Ajax instead:
-	//	|	define(["dojo/query"], function(query){
-	// 	|	query("input[type='submit']").on("click", function(e){
-	//	|		dojo.stopEvent(e); // prevent sending the form
-	//	|		var btn = e.target;
-	//	|		dojo.xhrPost({
-	//	|			form: btn.form,
-	//	|			load: function(data){
-	//	|				// replace the form with the response
-	//	|				var div = dojo.doc.createElement("div");
-	//	|				dojo.place(div, btn.form, "after");
-	//	|				div.innerHTML = data;
-	//	|				dojo.style(btn.form, "display", "none");
-	//	|			}
-	//	|		});
-	//	|	}); 
-	//
-	// description:
-	//		dojo/query is responsible for loading the appropriate query engine and wrapping 
-	//		its results with a `dojo.NodeList`. You can use dojo/query with a specific selector engine
-	//		by using it as a plugin. For example, if you installed the sizzle package, you could
-	//		use it as the selector engine with:
-	//		|	define("dojo/query!sizzle", function(query){
-	//		|		query("div")...
-	//
-	//		The id after the ! can be a module id of the selector engine or one of the following values:
-	//		|	+ acme: This is the default engine used by Dojo base, and will ensure that the full
-	//		|	Acme engine is always loaded. 
-	//		|	
-	//		|	+ css2: If the browser has a native selector engine, this will be used, otherwise a
-	//		|	very minimal lightweight selector engine will be loaded that can do simple CSS2 selectors
-	//		|	(by #id, .class, tag, and [name=value] attributes, with standard child or descendant (>)
-	//		|	operators) and nothing more.
-	//		|
-	//		|	+ css2.1: If the browser has a native selector engine, this will be used, otherwise the
-	//		|	full Acme engine will be loaded. 
-	//		|	
-	//		|	+ css3: If the browser has a native selector engine with support for CSS3 pseudo
-	//		|	selectors (most modern browsers except IE8), this will be used, otherwise the
-	//		|	full Acme engine will be loaded.
-	//		|	
-	//		|	+ Or the module id of a selector engine can be used to explicitly choose the selector engine
-	//		
-	//		For example, if you are using CSS3 pseudo selectors in module, you can specify that
-	//		you will need support them with:
-	//		|	define("dojo/query!css3", function(query){
-	//		|		query('#t > h3:nth-child(odd)')...
-	//
-	//		You can also choose the selector engine/load configuration by setting the <FIXME:what is the configuration setting?>.
-	//		For example:
-	//		|	<script data-dojo-config="query-selector:'css3'" src="dojo.js"></script>
-	//		
-	return new dojo.NodeList(); // dojo.NodeList
-};
-=====*/
-
-function queryForEngine(engine, NodeList){
-	var query = function(/*String*/ query, /*String|DOMNode?*/ root){
-		//	summary:
-		//		Returns nodes which match the given CSS selector, searching the
-		//		entire document by default but optionally taking a node to scope
-		//		the search by. Returns an instance of dojo.NodeList.
-		if(typeof root == "string"){
-			root = dom.byId(root);
-			if(!root){
-				return new NodeList([]);
+	function queryForEngine(engine, NodeList){
+		var query = function(/*String*/ query, /*String|DOMNode?*/ root){
+			// summary:
+			//		Returns nodes which match the given CSS selector, searching the
+			//		entire document by default but optionally taking a node to scope
+			//		the search by. Returns an instance of NodeList.
+			if(typeof root == "string"){
+				root = dom.byId(root);
+				if(!root){
+					return new NodeList([]);
+				}
 			}
+			var results = typeof query == "string" ? engine(query, root) : query ? query.orphan ? query : [query] : [];
+			if(results.orphan){
+				// already wrapped
+				return results;
+			}
+			return new NodeList(results);
+		};
+		query.matches = engine.match || function(node, selector, root){
+			// summary:
+			//		Test to see if a node matches a selector
+			return query.filter([node], selector, root).length > 0;
+		};
+		// the engine provides a filtering function, use it to for matching
+		query.filter = engine.filter || function(nodes, selector, root){
+			// summary:
+			//		Filters an array of nodes. Note that this does not guarantee to return a NodeList, just an array.
+			return query(selector, root).filter(function(node){
+				return array.indexOf(nodes, node) > -1;
+			});
+		};
+		if(typeof engine != "function"){
+			var search = engine.search;
+			engine = function(selector, root){
+				// Slick does it backwards (or everyone else does it backwards, probably the latter)
+				return search(root || document, selector);
+			};
 		}
-		var results = typeof query == "string" ? engine(query, root) : query.orphan ? query : [query];
-		if(results.orphan){
-			// already wrapped
-			return results; 
-		}
-		return new NodeList(results);
-	};
-	query.matches = engine.match || function(node, selector, root){
+		return query;
+	}
+	var query = queryForEngine(defaultEngine, NodeList);
+	/*=====
+	query = function(selector, context){
 		// summary:
-		//		Test to see if a node matches a selector
-		return query.filter([node], selector, root).length > 0;
-	};
-	// the engine provides a filtering function, use it to for matching
-	query.filter = engine.filter || function(nodes, selector, root){
+		//		This modules provides DOM querying functionality. The module export is a function
+		//		that can be used to query for DOM nodes by CSS selector and returns a NodeList
+		//		representing the matching nodes.
+		// selector: String
+		//		A CSS selector to search for.
+		// context: String|DomNode?
+		//		An optional context to limit the searching scope. Only nodes under `context` will be
+		//		scanned.
+		// example:
+		//		add an onclick handler to every submit button in the document
+		//		which causes the form to be sent via Ajax instead:
+		//	|	require(["dojo/query"], function(query){
+		//	|		query("input[type='submit']").on("click", function(e){
+		//	|			dojo.stopEvent(e); // prevent sending the form
+		//	|			var btn = e.target;
+		//	|			dojo.xhrPost({
+		//	|				form: btn.form,
+		//	|				load: function(data){
+		//	|					// replace the form with the response
+		//	|					var div = dojo.doc.createElement("div");
+		//	|					dojo.place(div, btn.form, "after");
+		//	|					div.innerHTML = data;
+		//	|					dojo.style(btn.form, "display", "none");
+		//	|				}
+		//	|			});
+		//	|		});
+		// |	});
+		//
+		// description:
+		//		dojo/query is responsible for loading the appropriate query engine and wrapping
+		//		its results with a `NodeList`. You can use dojo/query with a specific selector engine
+		//		by using it as a plugin. For example, if you installed the sizzle package, you could
+		//		use it as the selector engine with:
+		//		|	require(["dojo/query!sizzle"], function(query){
+		//		|		query("div")...
+		//
+		//		The id after the ! can be a module id of the selector engine or one of the following values:
+		//
+		//		- acme: This is the default engine used by Dojo base, and will ensure that the full
+		//		Acme engine is always loaded.
+		//
+		//		- css2: If the browser has a native selector engine, this will be used, otherwise a
+		//		very minimal lightweight selector engine will be loaded that can do simple CSS2 selectors
+		//		(by #id, .class, tag, and [name=value] attributes, with standard child or descendant (>)
+		//		operators) and nothing more.
+		//
+		//		- css2.1: If the browser has a native selector engine, this will be used, otherwise the
+		//		full Acme engine will be loaded.
+		//
+		//		- css3: If the browser has a native selector engine with support for CSS3 pseudo
+		//		selectors (most modern browsers except IE8), this will be used, otherwise the
+		//		full Acme engine will be loaded.
+		//
+		//		- Or the module id of a selector engine can be used to explicitly choose the selector engine
+		//
+		//		For example, if you are using CSS3 pseudo selectors in module, you can specify that
+		//		you will need support them with:
+		//		|	require(["dojo/query!css3"], function(query){
+		//		|		query('#t > h3:nth-child(odd)')...
+		//
+		//		You can also choose the selector engine/load configuration by setting the query-selector:
+		//		For example:
+		//		|	<script data-dojo-config="query-selector:'css3'" src="dojo.js"></script>
+		//
+		return new NodeList(); // dojo/NodeList
+	 };
+	 =====*/
+
+	// the query that is returned from this module is slightly different than dojo.query,
+	// because dojo.query has to maintain backwards compatibility with returning a
+	// true array which has performance problems. The query returned from the module
+	// does not use true arrays, but rather inherits from Array, making it much faster to
+	// instantiate.
+	dojo.query = queryForEngine(defaultEngine, function(array){
+		// call it without the new operator to invoke the back-compat behavior that returns a true array
+		return NodeList(array);	// dojo/NodeList
+	});
+
+	query.load = function(id, parentRequire, loaded){
 		// summary:
-		//		Filters an array of nodes. Note that this does not guarantee to return a dojo.NodeList, just an array.
-		return query(selector, root).filter(function(node){
-			return array.indexOf(nodes, node) > -1;
+		//		can be used as AMD plugin to conditionally load new query engine
+		// example:
+		//	|	require(["dojo/query!custom"], function(qsa){
+		//	|		// loaded selector/custom.js as engine
+		//	|		qsa("#foobar").forEach(...);
+		//	|	});
+		loader.load(id, parentRequire, function(engine){
+			loaded(queryForEngine(engine, NodeList));
 		});
 	};
-	if(typeof engine != "function"){
-		var search = engine.search;
-		engine = function(selector, root){
-			// Slick does it backwards (or everyone else does it backwards, probably the latter)
-			return search(root || document, selector);
-		};
-	}
-	return query;
-}
-var query = queryForEngine(defaultEngine, NodeList);
-// the query that is returned from this module is slightly different than dojo.query,
-// because dojo.query has to maintain backwards compatibility with returning a
-// true array which has performance problems. The query returned from the module
-// does not use true arrays, but rather inherits from Array, making it much faster to
-// instantiate.
-dojo.query = queryForEngine(defaultEngine, function(array){
-	// call it without the new operator to invoke the back-compat behavior that returns a true array
-	return NodeList(array);
-});
 
-query.load = /*===== dojo.query.load= ======*/ function(id, parentRequire, loaded, config){
-	// summary: can be used as AMD plugin to conditionally load new query engine
-	// example:
-	//	|	define(["dojo/query!custom"], function(qsa){ 
-	//	|		// loaded selector/custom.js as engine
-	//	|		qsa("#foobar").forEach(...);
-	//	|	});
-	loader.load(id, parentRequire, function(engine){
-		loaded(queryForEngine(engine, NodeList));
-	});
-};
-
-dojo._filterQueryResult = query._filterResult = function(nodes, selector, root){
-	return new NodeList(query.filter(nodes, selector, root));
-};
-dojo.NodeList = query.NodeList = NodeList;
-return query;
+	dojo._filterQueryResult = query._filterResult = function(nodes, selector, root){
+		return new NodeList(query.filter(nodes, selector, root));
+	};
+	dojo.NodeList = query.NodeList = NodeList;
+	return query;
 });