dojo-rails 0.9.8 → 0.9.9

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

@@ -0,0 +1,195 @@
+/*
+	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/query",["./_base/kernel","./has","./dom","./on","./_base/array","./_base/lang","./selector/_loader","./selector/_loader!default"],function(_1,_2,_3,on,_4,_5,_6,_7){
+"use strict";
+_2.add("array-extensible",function(){
+return _5.delegate([],{length:1}).length==1&&!_2("bug-for-in-skips-shadowed");
+});
+var ap=Array.prototype,_8=ap.slice,_9=ap.concat,_a=_4.forEach;
+var _b=function(a,_c,_d){
+var _e=new (_d||this._NodeListCtor||nl)(a);
+return _c?_e._stash(_c):_e;
+};
+var _f=function(f,a,o){
+a=[0].concat(_8.call(a,0));
+o=o||_1.global;
+return function(_10){
+a[0]=_10;
+return f.apply(o,a);
+};
+};
+var _11=function(f,o){
+return function(){
+this.forEach(_f(f,arguments,o));
+return this;
+};
+};
+var _12=function(f,o){
+return function(){
+return this.map(_f(f,arguments,o));
+};
+};
+var _13=function(f,o){
+return function(){
+return this.filter(_f(f,arguments,o));
+};
+};
+var _14=function(f,g,o){
+return function(){
+var a=arguments,_15=_f(f,a,o);
+if(g.call(o||_1.global,a)){
+return this.map(_15);
+}
+this.forEach(_15);
+return this;
+};
+};
+var _16=function(_17){
+var _18=this instanceof nl&&_2("array-extensible");
+if(typeof _17=="number"){
+_17=Array(_17);
+}
+var _19=(_17&&"length" in _17)?_17:arguments;
+if(_18||!_19.sort){
+var _1a=_18?this:[],l=_1a.length=_19.length;
+for(var i=0;i<l;i++){
+_1a[i]=_19[i];
+}
+if(_18){
+return _1a;
+}
+_19=_1a;
+}
+_5._mixin(_19,nlp);
+_19._NodeListCtor=function(_1b){
+return nl(_1b);
+};
+return _19;
+};
+var nl=_16,nlp=nl.prototype=_2("array-extensible")?[]:{};
+nl._wrap=nlp._wrap=_b;
+nl._adaptAsMap=_12;
+nl._adaptAsForEach=_11;
+nl._adaptAsFilter=_13;
+nl._adaptWithCondition=_14;
+_a(["slice","splice"],function(_1c){
+var f=ap[_1c];
+nlp[_1c]=function(){
+return this._wrap(f.apply(this,arguments),_1c=="slice"?this:null);
+};
+});
+_a(["indexOf","lastIndexOf","every","some"],function(_1d){
+var f=_4[_1d];
+nlp[_1d]=function(){
+return f.apply(_1,[this].concat(_8.call(arguments,0)));
+};
+});
+_5.extend(_16,{constructor:nl,_NodeListCtor:nl,toString:function(){
+return this.join(",");
+},_stash:function(_1e){
+this._parent=_1e;
+return this;
+},on:function(_1f,_20){
+var _21=this.map(function(_22){
+return on(_22,_1f,_20);
+});
+_21.remove=function(){
+for(var i=0;i<_21.length;i++){
+_21[i].remove();
+}
+};
+return _21;
+},end:function(){
+if(this._parent){
+return this._parent;
+}else{
+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;
+});
+return this._wrap(_9.apply(t,m),this);
+},map:function(_24,obj){
+return this._wrap(_4.map(this,_24,obj),this);
+},forEach:function(_25,_26){
+_a(this,_25,_26);
+return this;
+},filter:function(_27){
+var a=arguments,_28=this,_29=0;
+if(typeof _27=="string"){
+_28=_2a._filterResult(this,a[0]);
+if(a.length==1){
+return _28._stash(this);
+}
+_29=1;
+}
+return this._wrap(_4.filter(_28,a[_29],a[_29+1]),this);
+},instantiate:function(_2b,_2c){
+var c=_5.isFunction(_2b)?_2b:_5.getObject(_2b);
+_2c=_2c||{};
+return this.forEach(function(_2d){
+new c(_2c,_2d);
+});
+},at:function(){
+var t=new this._NodeListCtor(0);
+_a(arguments,function(i){
+if(i<0){
+i=this.length+i;
+}
+if(this[i]){
+t.push(this[i]);
+}
+},this);
+return t._stash(this);
+}});
+function _2e(_2f,_30){
+var _31=function(_32,_33){
+if(typeof _33=="string"){
+_33=_3.byId(_33);
+if(!_33){
+return new _30([]);
+}
+}
+var _34=typeof _32=="string"?_2f(_32,_33):_32.orphan?_32:[_32];
+if(_34.orphan){
+return _34;
+}
+return new _30(_34);
+};
+_31.matches=_2f.match||function(_35,_36,_37){
+return _31.filter([_35],_36,_37).length>0;
+};
+_31.filter=_2f.filter||function(_38,_39,_3a){
+return _31(_39,_3a).filter(function(_3b){
+return _4.indexOf(_38,_3b)>-1;
+});
+};
+if(typeof _2f!="function"){
+var _3c=_2f.search;
+_2f=function(_3d,_3e){
+return _3c(_3e||document,_3d);
+};
+}
+return _31;
+};
+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));
+});
+};
+_1._filterQueryResult=_2a._filterResult=function(_44,_45,_46){
+return new _16(_2a.filter(_44,_45,_46));
+};
+_1.NodeList=_2a.NodeList=_16;
+return _2a;
+});

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

@@ -0,0 +1,713 @@
+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";
+
+	has.add("array-extensible", function(){
+		// test to see if we can extend an array (not supported in old IE)
+		return lang.delegate([], {length: 1}).length == 1 && !has("bug-for-in-skips-shadowed");
+	});
+	
+	var ap = Array.prototype, aps = ap.slice, apc = ap.concat, forEach = array.forEach;
+
+	var tnl = function(/*Array*/ a, /*dojo.NodeList?*/ parent, /*Function?*/ NodeListCtor){
+		// summary:
+		//		decorate an array to make it look like a `dojo.NodeList`.
+		// a:
+		//		Array of nodes to decorate.
+		// parent:
+		//		An optional parent NodeList that generated the current
+		//		list of nodes. Used to call _stash() so the parent NodeList
+		//		can be accessed via end() later.
+		// NodeListCtor:
+		//		An optional constructor function to use for any
+		//		new NodeList calls. This allows a certain chain of
+		//		NodeList calls to use a different object than dojo.NodeList.
+		var nodeList = new (NodeListCtor || this._NodeListCtor || nl)(a);
+		return parent ? nodeList._stash(parent) : nodeList;
+	};
+
+	var loopBody = function(f, a, o){
+		a = [0].concat(aps.call(a, 0));
+		o = o || dojo.global;
+		return function(node){
+			a[0] = node;
+			return f.apply(o, a);
+		};
+	};
+
+	// adapters
+
+	var adaptAsForEach = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the forEach-type
+		//		actions. The initial object is returned from the specialized
+		//		function.
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			this.forEach(loopBody(f, arguments, o));
+			return this;	// Object
+		};
+	};
+
+	var adaptAsMap = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the map-type
+		//		actions. The return is a new array of values, as via `dojo.map`
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			return this.map(loopBody(f, arguments, o));
+		};
+	};
+
+	var adaptAsFilter = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the filter-type actions
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			return this.filter(loopBody(f, arguments, o));
+		};
+	};
+
+	var adaptWithCondition = function(f, g, o){
+		// summary:
+		//		adapts a single node function to be used in the map-type
+		//		actions, behaves like forEach() or map() depending on arguments
+		// f: Function
+		//		a function to adapt
+		// g: Function
+		//		a condition function, if true runs as map(), otherwise runs as forEach()
+		// o: Object?
+		//		an optional context for f and g
+		return function(){
+			var a = arguments, body = loopBody(f, a, o);
+			if(g.call(o || dojo.global, a)){
+				return this.map(body);	// self
+			}
+			this.forEach(body);
+			return this;	// self
+		};
+	};
+
+	var NodeList = function(array){
+		// summary:
+		//		dojo.NodeList is an of 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
+		//		core Dojo APIs for Array iteration and manipulation, DOM
+		//		manipulation, and event handling. Instead of needing to dig up
+		//		functions in the dojo.* namespace, NodeLists generally make the
+		//		full power of Dojo available for DOM manipulation tasks in a
+		//		simple, chainable way.
+		// example:
+		//		create a node list from a node
+		//		|	new dojo.NodeList(dojo.byId("foo"));
+		// example:
+		//		get a NodeList from a CSS query and iterate on it
+		//		|	var l = dojo.query(".thinger");
+		//		|	l.forEach(function(node, index, nodeList){
+		//		|		console.log(index, node.innerHTML);
+		//		|	});
+		// example:
+		//		use native and Dojo-provided array methods to manipulate a
+		//		NodeList without needing to use dojo.* functions explicitly:
+		//		|	var l = dojo.query(".thinger");
+		//		|	// since NodeLists are real arrays, they have a length
+		//		|	// property that is both readable and writable and
+		//		|	// push/pop/shift/unshift methods
+		//		|	console.log(l.length);
+		//		|	l.push(dojo.create("span"));
+		//		|
+		//		|	// dojo's normalized array methods work too:
+		//		|	console.log( l.indexOf(dojo.byId("foo")) );
+		//		|	// ...including the special "function as string" shorthand
+		//		|	console.log( l.every("item.nodeType == 1") );
+		//		|
+		//		|	// NodeLists can be [..] indexed, or you can use the at()
+		//		|	// function to get specific items wrapped in a new NodeList:
+		//		|	var node = l[3]; // the 4th element
+		//		|	var newList = l.at(1, 3); // the 2nd and 4th elements
+		// example:
+		//		the style functions you expect are all there too:
+		//		|	// style() as a getter...
+		//		|	var borders = dojo.query(".thinger").style("border");
+		//		|	// ...and as a setter:
+		//		|	dojo.query(".thinger").style("border", "1px solid black");
+		//		|	// class manipulation
+		//		|	dojo.query("li:nth-child(even)").addClass("even");
+		//		|	// even getting the coordinates of all the items
+		//		|	var coords = dojo.query(".thinger").coords();
+		// example:
+		//		DOM manipulation functions from the dojo.* namespace area also
+		//		available:
+		//		|	// remove all of the elements in the list from their
+		//		|	// parents (akin to "deleting" them from the document)
+		//		|	dojo.query(".thinger").orphan();
+		//		|	// place all elements in the list at the front of #foo
+		//		|	dojo.query(".thinger").place("foo", "first");
+		// example:
+		//		Event handling couldn't be easier. `dojo.connect` is mapped in,
+		//		and shortcut handlers are provided for most DOM events:
+		//		|	// like dojo.connect(), but with implicit scope
+		//		|	dojo.query("li").connect("onclick", console, "log");
+		//		|
+		//		|	// many common event handlers are already available directly:
+		//		|	dojo.query("li").onclick(console, "log");
+		//		|	var toggleHovered = dojo.hitch(dojo, "toggleClass", "hovered");
+		//		|	dojo.query("p")
+		//		|		.onmouseenter(toggleHovered)
+		//		|		.onmouseleave(toggleHovered);
+		// example:
+		//		chainability is a key advantage of NodeLists:
+		//		|	dojo.query(".thinger")
+		//		|		.onclick(function(e){ /* ... */ })
+		//		|		.at(1, 3, 8) // get a subset
+		//		|			.style("padding", "5px")
+		//		|			.forEach(console.log);
+		var isNew = this instanceof nl && has("array-extensible");
+		if(typeof array == "number"){
+			array = Array(array);
+		}
+		var nodeArray = (array && "length" in array) ? array : arguments;
+		if(isNew || !nodeArray.sort){
+			// make sure it's a real array before we pass it on to be wrapped 
+			var target = isNew ? this : [],
+				l = target.length = nodeArray.length;
+			for(var i = 0; i < l; i++){
+				target[i] = nodeArray[i];
+			}
+			if(isNew){
+				// called with new operator, this means we are going to use this instance and push
+				// the nodes on to it. This is usually much faster since the NodeList properties
+				//	don't need to be copied (unless the list of nodes is extremely large).
+				return target;
+			}
+			nodeArray = target;
+		}
+		// called without new operator, use a real array and copy prototype properties,
+		// this is slower and exists for back-compat. Should be removed in 2.0.
+		lang._mixin(nodeArray, nlp);
+		nodeArray._NodeListCtor = function(array){
+			// call without new operator to preserve back-compat behavior
+			return nl(array);
+		};
+		return nodeArray;
+	};
+	
+	var nl = NodeList, nlp = nl.prototype = 
+		has("array-extensible") ? [] : {};// extend an array if it is extensible
+
+	// expose adapters and the wrapper as private functions
+
+	nl._wrap = nlp._wrap = tnl;
+	nl._adaptAsMap = adaptAsMap;
+	nl._adaptAsForEach = adaptAsForEach;
+	nl._adaptAsFilter  = adaptAsFilter;
+	nl._adaptWithCondition = adaptWithCondition;
+
+	// mass assignment
+
+	// add array redirectors
+	forEach(["slice", "splice"], function(name){
+		var f = ap[name];
+		//Use a copy of the this array via this.slice() to allow .end() to work right in the splice case.
+		// CANNOT apply ._stash()/end() to splice since it currently modifies
+		// the existing this array -- it would break backward compatibility if we copy the array before
+		// the splice so that we can use .end(). So only doing the stash option to this._wrap for slice.
+		nlp[name] = function(){ return this._wrap(f.apply(this, arguments), name == "slice" ? this : null); };
+	});
+	// concat should be here but some browsers with native NodeList have problems with it
+
+	// add array.js redirectors
+	forEach(["indexOf", "lastIndexOf", "every", "some"], function(name){
+		var f = array[name];
+		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,
+		_NodeListCtor: nl,
+		toString: function(){
+			// Array.prototype.toString can't be applied to objects, so we use join
+			return this.join(",");
+		},
+		_stash: function(parent){
+			// summary:
+			//		private function to hold to a parent NodeList. end() to return the parent NodeList.
+			//
+			// example:
+			// How to make a `dojo.NodeList` method that only returns the third node in
+			// the dojo.NodeList but allows access to the original NodeList by using this._stash:
+			//	|	dojo.extend(dojo.NodeList, {
+			//	|		third: function(){
+			//	|			var newNodeList = dojo.NodeList(this[2]);
+			//	|			return newNodeList._stash(this);
+			//	|		}
+			//	|	});
+			//	|	// then see how _stash applies a sub-list, to be .end()'ed out of
+			//	|	dojo.query(".foo")
+			//	|		.third()
+			//	|			.addClass("thirdFoo")
+			//	|		.end()
+			//	|		// access to the orig .foo list
+			//	|		.removeClass("foo")
+			//	|
+			//
+			this._parent = parent;
+			return this; //dojo.NodeList
+		},
+
+		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
+			//		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.
+			//		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){
+				return on(node, eventName, listener); // TODO: apply to the NodeList so the same selector engine is used for matches
+			});
+			handles.remove = function(){
+				for(var i = 0; i < handles.length; i++){
+					handles[i].remove();
+				}
+			};
+			return handles;
+		},
+
+		end: function(){
+			// summary:
+			//		Ends use of the current `dojo.NodeList` by returning the previous dojo.NodeList
+			//		that generated the current dojo.NodeList.
+			// description:
+			//		Returns the `dojo.NodeList` that generated the current `dojo.NodeList`. If there
+			//		is no parent dojo.NodeList, an empty dojo.NodeList is returned.
+			// example:
+			//	|	dojo.query("a")
+			//	|		.filter(".disabled")
+			//	|			// operate on the anchors that only have a disabled class
+			//	|			.style("color", "grey")
+			//	|		.end()
+			//	|		// jump back to the list of anchors
+			//	|		.style(...)
+			//
+			if(this._parent){
+				return this._parent;
+			}else{
+				//Just return empty list.
+				return new this._NodeListCtor(0);
+			}
+		},
+
+		// http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array#Methods
+
+		// FIXME: handle return values for #3244
+		//		http://trac.dojotoolkit.org/ticket/3244
+
+		// FIXME:
+		//		need to wrap or implement:
+		//			join (perhaps w/ innerHTML/outerHTML overload for toString() of items?)
+		//			reduce
+		//			reduceRight
+
+		/*=====
+		slice: function(begin, end){
+			// summary:
+			//		Returns a new NodeList, maintaining this one in place
+			// description:
+			//		This method behaves exactly like the Array.slice method
+			//		with the caveat that it returns a dojo.NodeList and not a
+			//		raw Array. For more details, see Mozilla's (slice
+			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:slice]
+			// begin: Integer
+			//		Can be a positive or negative integer, with positive
+			//		integers noting the offset to begin at, and negative
+			//		integers denoting an offset from the end (i.e., to the left
+			//		of the end)
+			// end: Integer?
+			//		Optional parameter to describe what position relative to
+			//		the NodeList's zero index to end the slice at. Like begin,
+			//		can be positive or negative.
+			return this._wrap(a.slice.apply(this, arguments));
+		},
+
+		splice: function(index, howmany, item){
+			// summary:
+			//		Returns a new NodeList, manipulating this NodeList based on
+			//		the arguments passed, potentially splicing in new elements
+			//		at an offset, optionally deleting elements
+			// description:
+			//		This method behaves exactly like the Array.splice method
+			//		with the caveat that it returns a dojo.NodeList and not a
+			//		raw Array. For more details, see Mozilla's (splice
+			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:splice]
+			//		For backwards compatibility, calling .end() on the spliced NodeList
+			//		does not return the original NodeList -- splice alters the NodeList in place.
+			// index: Integer
+			//		begin can be a positive or negative integer, with positive
+			//		integers noting the offset to begin at, and negative
+			//		integers denoting an offset from the end (i.e., to the left
+			//		of the end)
+			// howmany: Integer?
+			//		Optional parameter to describe what position relative to
+			//		the NodeList's zero index to end the slice at. Like begin,
+			//		can be positive or negative.
+			// item: Object...?
+			//		Any number of optional parameters may be passed in to be
+			//		spliced into the NodeList
+			// returns:
+			//		dojo.NodeList
+			return this._wrap(a.splice.apply(this, arguments));
+		},
+
+		indexOf: function(value, fromIndex){
+			// summary:
+			//		see dojo.indexOf(). The primary difference is that the acted-on
+			//		array is implicitly this NodeList
+			// value: Object:
+			//		The value to search for.
+			// fromIndex: Integer?:
+			//		The location to start searching from. Optional. Defaults to 0.
+			// description:
+			//		For more details on the behavior of indexOf, see Mozilla's
+			//		(indexOf
+			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:indexOf]
+			// returns:
+			//		Positive Integer or 0 for a match, -1 of not found.
+			return d.indexOf(this, value, fromIndex); // Integer
+		},
+
+		lastIndexOf: function(value, fromIndex){
+			// summary:
+			//		see dojo.lastIndexOf(). The primary difference is that the
+			//		acted-on array is implicitly this NodeList
+			// description:
+			//		For more details on the behavior of lastIndexOf, see
+			//		Mozilla's (lastIndexOf
+			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:lastIndexOf]
+			// value: Object
+			//		The value to search for.
+			// fromIndex: Integer?
+			//		The location to start searching from. Optional. Defaults to 0.
+			// returns:
+			//		Positive Integer or 0 for a match, -1 of not found.
+			return d.lastIndexOf(this, value, fromIndex); // Integer
+		},
+
+		every: function(callback, thisObject){
+			// summary:
+			//		see `dojo.every()` and the (Array.every
+			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:every].
+			//		Takes the same structure of arguments and returns as
+			//		dojo.every() with the caveat that the passed array is
+			//		implicitly this NodeList
+			// callback: Function: the callback
+			// thisObject: Object?: the context
+			return d.every(this, callback, thisObject); // Boolean
+		},
+
+		some: function(callback, thisObject){
+			// summary:
+			//		Takes the same structure of arguments and returns as
+			//		`dojo.some()` with the caveat that the passed array is
+			//		implicitly this NodeList.  See `dojo.some()` and Mozilla's
+			//		(Array.some
+			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some].
+			// callback: Function: the callback
+			// thisObject: Object?: the context
+			return d.some(this, callback, thisObject); // Boolean
+		},
+		=====*/
+
+		concat: function(item){
+			// summary:
+			//		Returns a new NodeList comprised of items in this NodeList
+			//		as well as items passed in as parameters
+			// description:
+			//		This method behaves exactly like the Array.concat method
+			//		with the caveat that it returns a `dojo.NodeList` and not a
+			//		raw Array. For more details, see the (Array.concat
+			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:concat]
+			// item: Object?
+			//		Any number of optional parameters may be passed in to be
+			//		spliced into the NodeList
+			// returns:
+			//		dojo.NodeList
+
+			//return this._wrap(apc.apply(this, arguments));
+			// the line above won't work for the native NodeList :-(
+
+			// implementation notes:
+			// 1) Native NodeList is not an array, and cannot be used directly
+			// in concat() --- the latter doesn't recognize it as an array, and
+			// does not inline it, but append as a single entity.
+			// 2) On some browsers (e.g., Safari) the "constructor" property is
+			// read-only and cannot be changed. So we have to test for both
+			// native NodeList and dojo.NodeList in this property to recognize
+			// the node list.
+
+			var t = lang.isArray(this) ? this : 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 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
+		},
+
+		forEach: function(callback, thisObj){
+			// summary:
+			//		see `dojo.forEach()`. The primary difference is that the acted-on
+			//		array is implicitly this NodeList. If you want the option to break out
+			//		of the forEach loop, use every() or some() instead.
+			forEach(this, callback, thisObj);
+			// non-standard return to allow easier chaining
+			return this; // dojo.NodeList
+		},
+		filter: function(/*String|Function*/ filter){
+			// summary:
+			//		"masks" the built-in javascript filter() method (supported
+			//		in Dojo via `dojo.filter`) to support passing a simple
+			//		string filter in addition to supporting filtering function
+			//		objects.
+			// filter:
+			//		If a string, a CSS rule like ".thinger" or "div > span".
+			// example:
+			//		"regular" JS filter syntax as exposed in dojo.filter:
+			//		|	dojo.query("*").filter(function(item){
+			//		|		// highlight every paragraph
+			//		|		return (item.nodeName == "p");
+			//		|	}).style("backgroundColor", "yellow");
+			// example:
+			//		the same filtering using a CSS selector
+			//		|	dojo.query("*").filter("p").styles("backgroundColor", "yellow");
+
+			var a = arguments, items = this, start = 0;
+			if(typeof filter == "string"){ // inline'd type check
+				items = 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
+				}
+				// 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
+		},
+		instantiate: function(/*String|Object*/ declaredClass, /*Object?*/ properties){
+			// summary:
+			//		Create a new instance of a specified class, using the
+			//		specified properties and each node in the nodeList as a
+			//		srcNodeRef.
+			// example:
+			//		Grabs all buttons in the page and converts them to diji.form.Buttons.
+			//	|	var buttons = dojo.query("button").instantiate("dijit.form.Button", {showLabel: true});
+			var c = lang.isFunction(declaredClass) ? declaredClass : lang.getObject(declaredClass);
+			properties = properties || {};
+			return this.forEach(function(node){
+				new c(properties, node);
+			});	// dojo.NodeList
+		},
+		at: function(/*===== index =====*/){
+			// summary:
+			//		Returns a new NodeList comprised of items in this NodeList
+			//		at the given index or indices.
+			//
+			// index: Integer...
+			//		One or more 0-based indices of items in the current
+			//		NodeList. A negative index will start at the end of the
+			//		list and go backwards.
+			//
+			// example:
+			//	Shorten the list to the first, second, and third elements
+			//	|	dojo.query("a").at(0, 1, 2).forEach(fn);
+			//
+			// example:
+			//	Retrieve the first and last elements of a unordered list:
+			//	|	dojo.query("ul > li").at(0, -1).forEach(cb);
+			//
+			// example:
+			//	Do something for the first element only, but end() out back to
+			//	the original list and continue chaining:
+			//	|	dojo.query("a").at(0).onclick(fn).end().forEach(function(n){
+			//	|		console.log(n); // all anchors on the page.
+			//	|	})
+			//
+			// returns:
+			//		dojo.NodeList
+			var t = new this._NodeListCtor(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
+		}
+	});
+
+
+/*===== 
+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([]);
+			}
+		}
+		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){
+		// 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 dojo.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);
+		};
+	}
+	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;
+});