dojo-rails 0.11.0 → 0.14.0

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

@@ -1,705 +0,0 @@
-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:
-		//		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:
-		//		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 query.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))); };
-	});
-
-	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(NodeList, {
-			//	|		third: function(){
-			//	|			var newNodeList = 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 `NodeList` by returning the previous NodeList
-			//		that generated the current NodeList.
-			// description:
-			//		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")
-			//	|			// 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](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
-			//		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](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
-			//		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
-			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
-			//		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](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
-		},
-
-		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](https://developer.mozilla.org/en/JavaScript/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](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
-			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](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
-		},
-		=====*/
-
-		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 `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
-
-			//return this._wrap(apc.apply(this, arguments));
-			// the line above won't work for the native NodeList, or for Dojo NodeLists either :-(
-
-			// implementation notes:
-			// 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 aps.call(a, 0);
-				});
-			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
-			//		NodeList (a subclass of Array)
-			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 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
-		},
-		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
-			//	|	query("a").at(0, 1, 2).forEach(fn);
-			//
-			// example:
-			//	Retrieve the first and last elements of a unordered list:
-			//	|	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:
-			//	|	query("a").at(0).onclick(fn).end().forEach(function(n){
-			//	|		console.log(n); // all anchors on the page.
-			//	|	})
-
-			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
-		}
-	});
-
-	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);
-			};
-		}
-		return query;
-	}
-	var query = queryForEngine(defaultEngine, NodeList);
-	/*=====
-	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 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:
-		//		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));
-		});
-	};
-
-	dojo._filterQueryResult = query._filterResult = function(nodes, selector, root){
-		return new NodeList(query.filter(nodes, selector, root));
-	};
-	dojo.NodeList = query.NodeList = NodeList;
-	return query;
-});