https://www.originalcosmoline.com/js/jquery.js

1
2
3/*!
4 * jQuery JavaScript Library v1.10.2
5 * http://jquery.com/
6 *
7 * Includes Sizzle.js
8 * http://sizzlejs.com/
9 *
10 * Copyright 2005, 2013 jQuery Foundation, Inc. and other contributors
11 * Released under the MIT license
12 * http://jquery.org/license
13 *
14 * Date: 2013-07-03T13:48Z
15 */
16(function( window, undefined ) {
17
18// Can't do this because several apps including ASP.NET trace
19// the stack via arguments.caller.callee and Firefox dies if
20// you try to trace through "use strict" call chains. (#13335)
21// Support: Firefox 18+
22//"use strict";
23var
24	// The deferred used on DOM ready
25	readyList,
26
27	// A central reference to the root jQuery(document)
28	rootjQuery,
29
30	// Support: IE<10
31	// For `typeof xmlNode.method` instead of `xmlNode.method !== undefined`
32	core_strundefined = typeof undefined,
33
34	// Use the correct document accordingly with window argument (sandbox)
35	location = window.location,
36	document = window.document,
37	docElem = document.documentElement,
38
39	// Map over jQuery in case of overwrite
40	_jQuery = window.jQuery,
41
42	// Map over the $ in case of overwrite
43	_$ = window.$,
44
45	// [[Class]] -> type pairs
46	class2type = {},
47
48	// List of deleted data cache ids, so we can reuse them
49	core_deletedIds = [],
50
51	core_version = "1.10.2",
52
53	// Save a reference to some core methods
54	core_concat = core_deletedIds.concat,
55	core_push = core_deletedIds.push,
56	core_slice = core_deletedIds.slice,
57	core_indexOf = core_deletedIds.indexOf,
58	core_toString = class2type.toString,
59	core_hasOwn = class2type.hasOwnProperty,
60	core_trim = core_version.trim,
61
62	// Define a local copy of jQuery
63	jQuery = function( selector, context ) {
64		// The jQuery object is actually just the init constructor 'enhanced'
65		return new jQuery.fn.init( selector, context, rootjQuery );
66	},
67
68	// Used for matching numbers
69	core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
70
71	// Used for splitting on whitespace
72	core_rnotwhite = /\S+/g,
73
74	// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
75	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
76
77	// A simple way to check for HTML strings
78	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
79	// Strict HTML recognition (#11290: must start with <)
80	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
81
82	// Match a standalone tag
83	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
84
85	// JSON RegExp
86	rvalidchars = /^[\],:{}\s]*$/,
87	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
88	rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
89	rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,
90
91	// Matches dashed string for camelizing
92	rmsPrefix = /^-ms-/,
93	rdashAlpha = /-([\da-z])/gi,
94
95	// Used by jQuery.camelCase as callback to replace()
96	fcamelCase = function( all, letter ) {
97		return letter.toUpperCase();
98	},
99
100	// The ready event handler
101	completed = function( event ) {
102
103		// readyState === "complete" is good enough for us to call the dom ready in oldIE
104		if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {
105			detach();
106			jQuery.ready();
107		}
108	},
109	// Clean-up method for dom ready events
110	detach = function() {
111		if ( document.addEventListener ) {
112			document.removeEventListener( "DOMContentLoaded", completed, false );
113			window.removeEventListener( "load", completed, false );
114
115		} else {
116			document.detachEvent( "onreadystatechange", completed );
117			window.detachEvent( "onload", completed );
118		}
119	};
120
121jQuery.fn = jQuery.prototype = {
122	// The current version of jQuery being used
123	jquery: core_version,
124
125	constructor: jQuery,
126	init: function( selector, context, rootjQuery ) {
127		var match, elem;
128
129		// HANDLE: $(""), $(null), $(undefined), $(false)
130		if ( !selector ) {
131			return this;
132		}
133
134		// Handle HTML strings
135		if ( typeof selector === "string" ) {
136			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
137				// Assume that strings that start and end with <> are HTML and skip the regex check
138				match = [ null, selector, null ];
139
140			} else {
141				match = rquickExpr.exec( selector );
142			}
143
144			// Match html or make sure no context is specified for #id
145			if ( match && (match[1] || !context) ) {
146
147				// HANDLE: $(html) -> $(array)
148				if ( match[1] ) {
149					context = context instanceof jQuery ? context[0] : context;
150
151					// scripts is true for back-compat
152					jQuery.merge( this, jQuery.parseHTML(
153						match[1],
154						context && context.nodeType ? context.ownerDocument || context : document,
155						true
156					) );
157
158					// HANDLE: $(html, props)
159					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
160						for ( match in context ) {
161							// Properties of context are called as methods if possible
162							if ( jQuery.isFunction( this[ match ] ) ) {
163								this[ match ]( context[ match ] );
164
165							// ...and otherwise set as attributes
166							} else {
167								this.attr( match, context[ match ] );
168							}
169						}
170					}
171
172					return this;
173
174				// HANDLE: $(#id)
175				} else {
176					elem = document.getElementById( match[2] );
177
178					// Check parentNode to catch when Blackberry 4.6 returns
179					// nodes that are no longer in the document #6963
180					if ( elem && elem.parentNode ) {
181						// Handle the case where IE and Opera return items
182						// by name instead of ID
183						if ( elem.id !== match[2] ) {
184							return rootjQuery.find( selector );
185						}
186
187						// Otherwise, we inject the element directly into the jQuery object
188						this.length = 1;
189						this[0] = elem;
190					}
191
192					this.context = document;
193					this.selector = selector;
194					return this;
195				}
196
197			// HANDLE: $(expr, $(...))
198			} else if ( !context || context.jquery ) {
199				return ( context || rootjQuery ).find( selector );
200
201			// HANDLE: $(expr, context)
202			// (which is just equivalent to: $(context).find(expr)
203			} else {
204				return this.constructor( context ).find( selector );
205			}
206
207		// HANDLE: $(DOMElement)
208		} else if ( selector.nodeType ) {
209			this.context = this[0] = selector;
210			this.length = 1;
211			return this;
212
213		// HANDLE: $(function)
214		// Shortcut for document ready
215		} else if ( jQuery.isFunction( selector ) ) {
216			return rootjQuery.ready( selector );
217		}
218
219		if ( selector.selector !== undefined ) {
220			this.selector = selector.selector;
221			this.context = selector.context;
222		}
223
224		return jQuery.makeArray( selector, this );
225	},
226
227	// Start with an empty selector
228	selector: "",
229
230	// The default length of a jQuery object is 0
231	length: 0,
232
233	toArray: function() {
234		return core_slice.call( this );
235	},
236
237	// Get the Nth element in the matched element set OR
238	// Get the whole matched element set as a clean array
239	get: function( num ) {
240		return num == null ?
241
242			// Return a 'clean' array
243			this.toArray() :
244
245			// Return just the object
246			( num < 0 ? this[ this.length + num ] : this[ num ] );
247	},
248
249	// Take an array of elements and push it onto the stack
250	// (returning the new matched element set)
251	pushStack: function( elems ) {
252
253		// Build a new jQuery matched element set
254		var ret = jQuery.merge( this.constructor(), elems );
255
256		// Add the old object onto the stack (as a reference)
257		ret.prevObject = this;
258		ret.context = this.context;
259
260		// Return the newly-formed element set
261		return ret;
262	},
263
264	// Execute a callback for every element in the matched set.
265	// (You can seed the arguments with an array of args, but this is
266	// only used internally.)
267	each: function( callback, args ) {
268		return jQuery.each( this, callback, args );
269	},
270
271	ready: function( fn ) {
272		// Add the callback
273		jQuery.ready.promise().done( fn );
274
275		return this;
276	},
277
278	slice: function() {
279		return this.pushStack( core_slice.apply( this, arguments ) );
280	},
281
282	first: function() {
283		return this.eq( 0 );
284	},
285
286	last: function() {
287		return this.eq( -1 );
288	},
289
290	eq: function( i ) {
291		var len = this.length,
292			j = +i + ( i < 0 ? len : 0 );
293		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
294	},
295
296	map: function( callback ) {
297		return this.pushStack( jQuery.map(this, function( elem, i ) {
298			return callback.call( elem, i, elem );
299		}));
300	},
301
302	end: function() {
303		return this.prevObject || this.constructor(null);
304	},
305
306	// For internal use only.
307	// Behaves like an Array's method, not like a jQuery method.
308	push: core_push,
309	sort: [].sort,
310	splice: [].splice
311};
312
313// Give the init function the jQuery prototype for later instantiation
314jQuery.fn.init.prototype = jQuery.fn;
315
316jQuery.extend = jQuery.fn.extend = function() {
317	var src, copyIsArray, copy, name, options, clone,
318		target = arguments[0] || {},
319		i = 1,
320		length = arguments.length,
321		deep = false;
322
323	// Handle a deep copy situation
324	if ( typeof target === "boolean" ) {
325		deep = target;
326		target = arguments[1] || {};
327		// skip the boolean and the target
328		i = 2;
329	}
330
331	// Handle case when target is a string or something (possible in deep copy)
332	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
333		target = {};
334	}
335
336	// extend jQuery itself if only one argument is passed
337	if ( length === i ) {
338		target = this;
339		--i;
340	}
341
342	for ( ; i < length; i++ ) {
343		// Only deal with non-null/undefined values
344		if ( (options = arguments[ i ]) != null ) {
345			// Extend the base object
346			for ( name in options ) {
347				src = target[ name ];
348				copy = options[ name ];
349
350				// Prevent never-ending loop
351				if ( target === copy ) {
352					continue;
353				}
354
355				// Recurse if we're merging plain objects or arrays
356				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
357					if ( copyIsArray ) {
358						copyIsArray = false;
359						clone = src && jQuery.isArray(src) ? src : [];
360
361					} else {
362						clone = src && jQuery.isPlainObject(src) ? src : {};
363					}
364
365					// Never move original objects, clone them
366					target[ name ] = jQuery.extend( deep, clone, copy );
367
368				// Don't bring in undefined values
369				} else if ( copy !== undefined ) {
370					target[ name ] = copy;
371				}
372			}
373		}
374	}
375
376	// Return the modified object
377	return target;
378};
379
380jQuery.extend({
381	// Unique for each copy of jQuery on the page
382	// Non-digits removed to match rinlinejQuery
383	expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ),
384
385	noConflict: function( deep ) {
386		if ( window.$ === jQuery ) {
387			window.$ = _$;
388		}
389
390		if ( deep && window.jQuery === jQuery ) {
391			window.jQuery = _jQuery;
392		}
393
394		return jQuery;
395	},
396
397	// Is the DOM ready to be used? Set to true once it occurs.
398	isReady: false,
399
400	// A counter to track how many items to wait for before
401	// the ready event fires. See #6781
402	readyWait: 1,
403
404	// Hold (or release) the ready event
405	holdReady: function( hold ) {
406		if ( hold ) {
407			jQuery.readyWait++;
408		} else {
409			jQuery.ready( true );
410		}
411	},
412
413	// Handle when the DOM is ready
414	ready: function( wait ) {
415
416		// Abort if there are pending holds or we're already ready
417		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
418			return;
419		}
420
421		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
422		if ( !document.body ) {
423			return setTimeout( jQuery.ready );
424		}
425
426		// Remember that the DOM is ready
427		jQuery.isReady = true;
428
429		// If a normal DOM Ready event fired, decrement, and wait if need be
430		if ( wait !== true && --jQuery.readyWait > 0 ) {
431			return;
432		}
433

677	},
678
679	// Use native String.trim function wherever possible
680	trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
681		function( text ) {
682			return text == null ?
683				"" :
684				core_trim.call( text );
685		} :
686
687		// Otherwise use our own trimming functionality
688		function( text ) {
689			return text == null ?
690				"" :
691				( text + "" ).replace( rtrim, "" );
692		},
693
694	// results is for internal usage only
695	makeArray: function( arr, results ) {
696		var ret = results || [];
697
698		if ( arr != null ) {
699			if ( isArraylike( Object(arr) ) ) {
700				jQuery.merge( ret,
701					typeof arr === "string" ?
702					[ arr ] : arr
703				);
704			} else {
705				core_push.call( ret, arr );
706			}
707		}
708
709		return ret;
710	},
711
712	inArray: function( elem, arr, i ) {
713		var len;
714
715		if ( arr ) {
716			if ( core_indexOf ) {
717				return core_indexOf.call( arr, elem, i );
718			}
719
720			len = arr.length;
721			i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
722
723			for ( ; i < len; i++ ) {
724				// Skip accessing in sparse arrays
725				if ( i in arr && arr[ i ] === elem ) {
726					return i;
727				}
728			}
729		}
730
731		return -1;
732	},
733
734	merge: function( first, second ) {
735		var l = second.length,
736			i = first.length,
737			j = 0;
738
739		if ( typeof l === "number" ) {
740			for ( ; j < l; j++ ) {
741				first[ i++ ] = second[ j ];
742			}
743		} else {
744			while ( second[j] !== undefined ) {
745				first[ i++ ] = second[ j++ ];
746			}
747		}
748
749		first.length = i;
750
751		return first;
752	},
753
754	grep: function( elems, callback, inv ) {
755		var retVal,
756			ret = [],
757			i = 0,
758			length = elems.length;
759		inv = !!inv;
760
761		// Go through the array, only saving the items
762		// that pass the validator function
763		for ( ; i < length; i++ ) {
764			retVal = !!callback( elems[ i ], i );
765			if ( inv !== retVal ) {
766				ret.push( elems[ i ] );
767			}
768		}
769
770		return ret;
771	},
772
773	// arg is for internal usage only
774	map: function( elems, callback, arg ) {
775		var value,
776			i = 0,
777			length = elems.length,
778			isArray = isArraylike( elems ),
779			ret = [];
780
781		// Go through the array, translating each of the items to their
782		if ( isArray ) {
783			for ( ; i < length; i++ ) {
784				value = callback( elems[ i ], i, arg );
785
786				if ( value != null ) {
787					ret[ ret.length ] = value;
788				}
789			}
790
791		// Go through every key on the object,
792		} else {
793			for ( i in elems ) {
794				value = callback( elems[ i ], i, arg );
795
796				if ( value != null ) {
797					ret[ ret.length ] = value;
798				}
799			}
800		}
801
802
803		// Flatten any nested arrays
804		return core_concat.apply( [], ret );
805	},
806
807	// A global GUID counter for objects
808	guid: 1,
809
810	// Bind a function to a context, optionally partially applying any
811	// arguments.
812	proxy: function( fn, context ) {
813		var args, proxy, tmp;
814
815		if ( typeof context === "string" ) {
816			tmp = fn[ context ];
817			context = fn;
818			fn = tmp;
819		}
820
821		// Quick check to determine if target is callable, in the spec
822		// this throws a TypeError, but we will just return undefined.
823		if ( !jQuery.isFunction( fn ) ) {
824			return undefined;
825		}
826
827		// Simulated bind
828		args = core_slice.call( arguments, 2 );
829		proxy = function() {
830			return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) );
831		};
832
833		// Set the guid of unique handler to the same of original handler, so it can be removed
834		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
835
836		return proxy;
837	},
838
839	// Multifunctional method to get and set values of a collection
840	// The value/s can optionally be executed if it's a function
841	access: function( elems, fn, key, value, chainable, emptyGet, raw ) {
842		var i = 0,
843			length = elems.length,
844			bulk = key == null;
845
846		// Sets many values
847		if ( jQuery.type( key ) === "object" ) {
848			chainable = true;
849			for ( i in key ) {
850				jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
851			}
852
853		// Sets one value
854		} else if ( value !== undefined ) {
855			chainable = true;
856
857			if ( !jQuery.isFunction( value ) ) {
858				raw = true;
859			}
860
861			if ( bulk ) {
862				// Bulk operations run against the entire set
863				if ( raw ) {
864					fn.call( elems, value );
865					fn = null;
866
867				// ...except when executing function values
868				} else {
869					bulk = fn;
870					fn = function( elem, key, value ) {

1434 * @param {Element|Object} elem An element or a document
1435 */
1436isXML = Sizzle.isXML = function( elem ) {
1437	// documentElement is verified for cases where it doesn't yet exist
1438	// (such as loading iframes in IE - #4833)
1439	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1440	return documentElement ? documentElement.nodeName !== "HTML" : false;
1441};
1442
1443// Expose support vars for convenience
1444support = Sizzle.support = {};
1445
1446/**
1447 * Sets document-related variables once based on the current document
1448 * @param {Element|Object} [doc] An element or document object to use to set the document
1449 * @returns {Object} Returns the current document
1450 */
1451setDocument = Sizzle.setDocument = function( node ) {
1452	var doc = node ? node.ownerDocument || node : preferredDoc,
1453		parent = doc.defaultView;
1454
1455	// If no document and documentElement is available, return
1456	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1457		return document;
1458	}
1459
1460	// Set our document
1461	document = doc;
1462	docElem = doc.documentElement;
1463
1464	// Support tests
1465	documentIsHTML = !isXML( doc );
1466
1467	// Support: IE>8
1468	// If iframe document is assigned to "document" variable and if iframe has been reloaded,
1469	// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
1470	// IE6-8 do not support the defaultView property so parent will be undefined
1471	if ( parent && parent.attachEvent && parent !== parent.top ) {
1472		parent.attachEvent( "onbeforeunload", function() {
1473			setDocument();
1474		});
1475	}
1476
1477	/* Attributes
1478	---------------------------------------------------------------------- */
1479
1480	// Support: IE<8
1481	// Verify that getAttribute really returns attributes and not properties (excepting IE8 booleans)
1482	support.attributes = assert(function( div ) {
1483		div.className = "i";
1484		return !div.getAttribute("className");
1485	});
1486
1487	/* getElement(s)By*
1488	---------------------------------------------------------------------- */
1489
1490	// Check if getElementsByTagName("*") returns only elements
1491	support.getElementsByTagName = assert(function( div ) {
1492		div.appendChild( doc.createComment("") );
1493		return !div.getElementsByTagName("*").length;
1494	});
1495
1496	// Check if getElementsByClassName can be trusted
1497	support.getElementsByClassName = assert(function( div ) {
1498		div.innerHTML = "<div class='a'></div><div class='a i'></div>";
1499
1500		// Support: Safari<4
1501		// Catch class over-caching
1502		div.firstChild.className = "i";
1503		// Support: Opera<10
1504		// Catch gEBCN failure to find non-leading classes
1505		return div.getElementsByClassName("i").length === 2;
1506	});
1507
1508	// Support: IE<10
1509	// Check if getElementById returns elements by name
1510	// The broken getElementById methods don't pick up programatically-set names,
1511	// so use a roundabout getElementsByName test
1512	support.getById = assert(function( div ) {
1513		docElem.appendChild( div ).id = expando;
1514		return !doc.getElementsByName || !doc.getElementsByName( expando ).length;
1515	});
1516
1517	// ID find and filter
1518	if ( support.getById ) {
1519		Expr.find["ID"] = function( id, context ) {
1520			if ( typeof context.getElementById !== strundefined && documentIsHTML ) {
1521				var m = context.getElementById( id );
1522				// Check parentNode to catch when Blackberry 4.6 returns
1523				// nodes that are no longer in the document #6963
1524				return m && m.parentNode ? [m] : [];
1525			}
1526		};
1527		Expr.filter["ID"] = function( id ) {
1528			var attrId = id.replace( runescape, funescape );
1529			return function( elem ) {
1530				return elem.getAttribute("id") === attrId;
1531			};
1532		};
1533	} else {
1534		// Support: IE6/7
1535		// getElementById is not reliable as a find shortcut
1536		delete Expr.find["ID"];
1537
1538		Expr.filter["ID"] =  function( id ) {
1539			var attrId = id.replace( runescape, funescape );
1540			return function( elem ) {
1541				var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
1542				return node && node.value === attrId;
1543			};
1544		};
1545	}
1546
1547	// Tag
1548	Expr.find["TAG"] = support.getElementsByTagName ?
1549		function( tag, context ) {
1550			if ( typeof context.getElementsByTagName !== strundefined ) {
1551				return context.getElementsByTagName( tag );
1552			}
1553		} :
1554		function( tag, context ) {
1555			var elem,
1556				tmp = [],
1557				i = 0,
1558				results = context.getElementsByTagName( tag );
1559
1560			// Filter out possible comments
1561			if ( tag === "*" ) {
1562				while ( (elem = results[i++]) ) {
1563					if ( elem.nodeType === 1 ) {
1564						tmp.push( elem );
1565					}
1566				}
1567
1568				return tmp;
1569			}
1570			return results;
1571		};
1572
1573	// Class
1574	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1575		if ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) {
1576			return context.getElementsByClassName( className );
1577		}
1578	};
1579
1580	/* QSA/matchesSelector
1581	---------------------------------------------------------------------- */
1582
1583	// QSA and matchesSelector support
1584
1585	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1586	rbuggyMatches = [];
1587
1588	// qSa(:focus) reports false when true (Chrome 21)
1589	// We allow this because of a bug in IE8/9 that throws an error
1590	// whenever `document.activeElement` is accessed on an iframe
1591	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1592	// See http://bugs.jquery.com/ticket/13378
1593	rbuggyQSA = [];
1594
1595	if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
1596		// Build QSA regex
1597		// Regex strategy adopted from Diego Perini
1598		assert(function( div ) {
1599			// Select is set to empty string on purpose
1600			// This is to test IE's treatment of not explicitly
1601			// setting a boolean content attribute,
1602			// since its presence should be enough
1603			// http://bugs.jquery.com/ticket/12359
1604			div.innerHTML = "<select><option selected=''></option></select>";
1605
1606			// Support: IE8
1607			// Boolean attributes and "value" are not treated correctly
1608			if ( !div.querySelectorAll("[selected]").length ) {
1609				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1610			}
1611
1612			// Webkit/Opera - :checked should return selected option elements
1613			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1614			// IE8 throws error here and will not see later tests
1615			if ( !div.querySelectorAll(":checked").length ) {
1616				rbuggyQSA.push(":checked");
1617			}
1618		});
1619
1620		assert(function( div ) {
1621
1622			// Support: Opera 10-12/IE8
1623			// ^= $= *= and empty values
1624			// Should not select anything
1625			// Support: Windows 8 Native Apps
1626			// The type attribute is restricted during .innerHTML assignment
1627			var input = doc.createElement("input");
1628			input.setAttribute( "type", "hidden" );
1629			div.appendChild( input ).setAttribute( "t", "" );
1630
1631			if ( div.querySelectorAll("[t^='']").length ) {
1632				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1633			}
1634
1635			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1636			// IE8 throws error here and will not see later tests
1637			if ( !div.querySelectorAll(":enabled").length ) {
1638				rbuggyQSA.push( ":enabled", ":disabled" );
1639			}
1640
1641			// Opera 10-11 does not throw on post-comma invalid pseudos
1642			div.querySelectorAll("*,:x");
1643			rbuggyQSA.push(",.*:");
1644		});
1645	}
1646
1647	if ( (support.matchesSelector = rnative.test( (matches = docElem.webkitMatchesSelector ||
1648		docElem.mozMatchesSelector ||
1649		docElem.oMatchesSelector ||
1650		docElem.msMatchesSelector) )) ) {
1651
1652		assert(function( div ) {
1653			// Check to see if it's possible to do matchesSelector
1654			// on a disconnected node (IE 9)
1655			support.disconnectedMatch = matches.call( div, "div" );
1656
1657			// This should fail with an exception
1658			// Gecko does not error, returns false instead
1659			matches.call( div, "[s!='']:x" );
1660			rbuggyMatches.push( "!=", pseudos );
1661		});
1662	}
1663
1664	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1665	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1666
1667	/* Contains
1668	---------------------------------------------------------------------- */
1669
1670	// Element contains another
1671	// Purposefully does not implement inclusive descendent
1672	// As in, an element does not contain itself
1673	contains = rnative.test( docElem.contains ) || docElem.compareDocumentPosition ?
1674		function( a, b ) {
1675			var adown = a.nodeType === 9 ? a.documentElement : a,
1676				bup = b && b.parentNode;
1677			return a === bup || !!( bup && bup.nodeType === 1 && (
1678				adown.contains ?
1679					adown.contains( bup ) :
1680					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1681			));
1682		} :
1683		function( a, b ) {
1684			if ( b ) {
1685				while ( (b = b.parentNode) ) {
1686					if ( b === a ) {
1687						return true;
1688					}
1689				}
1690			}
1691			return false;
1692		};
1693
1694	/* Sorting
1695	---------------------------------------------------------------------- */
1696
1697	// Document order sorting
1698	sortOrder = docElem.compareDocumentPosition ?
1699	function( a, b ) {
1700
1701		// Flag for duplicate removal
1702		if ( a === b ) {
1703			hasDuplicate = true;
1704			return 0;
1705		}
1706
1707		var compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition( b );
1708
1709		if ( compare ) {
1710			// Disconnected nodes
1711			if ( compare & 1 ||
1712				(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1713
1714				// Choose the first element that is related to our preferred document
1715				if ( a === doc || contains(preferredDoc, a) ) {
1716					return -1;
1717				}
1718				if ( b === doc || contains(preferredDoc, b) ) {
1719					return 1;
1720				}
1721
1722				// Maintain original order
1723				return sortInput ?
1724					( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1725					0;
1726			}
1727
1728			return compare & 4 ? -1 : 1;
1729		}
1730
1731		// Not directly comparable, sort on existence of method
1732		return a.compareDocumentPosition ? -1 : 1;
1733	} :
1734	function( a, b ) {
1735		var cur,
1736			i = 0,
1737			aup = a.parentNode,
1738			bup = b.parentNode,
1739			ap = [ a ],
1740			bp = [ b ];
1741
1742		// Exit early if the nodes are identical
1743		if ( a === b ) {
1744			hasDuplicate = true;
1745			return 0;
1746
1747		// Parentless nodes are either documents or disconnected
1748		} else if ( !aup || !bup ) {
1749			return a === doc ? -1 :
1750				b === doc ? 1 :
1751				aup ? -1 :
1752				bup ? 1 :
1753				sortInput ?
1754				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1755				0;
1756
1757		// If the nodes are siblings, we can do a quick check
1758		} else if ( aup === bup ) {
1759			return siblingCheck( a, b );
1760		}
1761
1762		// Otherwise we need full lists of their ancestors for comparison
1763		cur = a;
1764		while ( (cur = cur.parentNode) ) {
1765			ap.unshift( cur );
1766		}
1767		cur = b;
1768		while ( (cur = cur.parentNode) ) {
1769			bp.unshift( cur );
1770		}
1771
1772		// Walk down the tree looking for a discrepancy
1773		while ( ap[i] === bp[i] ) {
1774			i++;
1775		}
1776
1777		return i ?
1778			// Do a sibling check if the nodes have a common ancestor
1779			siblingCheck( ap[i], bp[i] ) :
1780
1781			// Otherwise nodes in our document sort first
1782			ap[i] === preferredDoc ? -1 :
1783			bp[i] === preferredDoc ? 1 :
1784			0;
1785	};
1786
1787	return doc;
1788};
1789
1790Sizzle.matches = function( expr, elements ) {
1791	return Sizzle( expr, null, null, elements );
1792};
1793
1794Sizzle.matchesSelector = function( elem, expr ) {
1795	// Set document vars if needed
1796	if ( ( elem.ownerDocument || elem ) !== document ) {
1797		setDocument( elem );
1798	}
1799
1800	// Make sure that attribute selectors are quoted
1801	expr = expr.replace( rattributeQuotes, "='$1']" );
1802
1803	if ( support.matchesSelector && documentIsHTML &&
1804		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1805		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1806
1807		try {
1808			var ret = matches.call( elem, expr );
1809
1810			// IE 9's matchesSelector returns false on disconnected nodes
1811			if ( ret || support.disconnectedMatch ||
1812					// As well, disconnected nodes are said to be in a document
1813					// fragment in IE 9
1814					elem.document && elem.document.nodeType !== 11 ) {
1815				return ret;
1816			}
1817		} catch(e) {}
1818	}
1819
1820	return Sizzle( expr, document, null, [elem] ).length > 0;
1821};
1822
1823Sizzle.contains = function( context, elem ) {
1824	// Set document vars if needed
1825	if ( ( context.ownerDocument || context ) !== document ) {
1826		setDocument( context );
1827	}
1828	return contains( context, elem );
1829};
1830
1831Sizzle.attr = function( elem, name ) {
1832	// Set document vars if needed
1833	if ( ( elem.ownerDocument || elem ) !== document ) {
1834		setDocument( elem );
1835	}
1836
1837	var fn = Expr.attrHandle[ name.toLowerCase() ],
1838		// Don't get fooled by Object.prototype properties (jQuery #13807)
1839		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1840			fn( elem, name, !documentIsHTML ) :
1841			undefined;
1842
1843	return val === undefined ?
1844		support.attributes || !documentIsHTML ?
1845			elem.getAttribute( name ) :
1846			(val = elem.getAttributeNode(name)) && val.specified ?
1847				val.value :
1848				null :
1849		val;
1850};
1851
1852Sizzle.error = function( msg ) {
1853	throw new Error( "Syntax error, unrecognized expression: " + msg );
1854};
1855
1856/**
1857 * Document sorting and removing duplicates
1858 * @param {ArrayLike} results
1859 */
1860Sizzle.uniqueSort = function( results ) {
1861	var elem,
1862		duplicates = [],
1863		j = 0,
1864		i = 0;
1865
1866	// Unless we *know* we can detect duplicates, assume their presence
1867	hasDuplicate = !support.detectDuplicates;
1868	sortInput = !support.sortStable && results.slice( 0 );
1869	results.sort( sortOrder );
1870
1871	if ( hasDuplicate ) {
1872		while ( (elem = results[i++]) ) {
1873			if ( elem === results[ i ] ) {
1874				j = duplicates.push( i );
1875			}
1876		}
1877		while ( j-- ) {
1878			results.splice( duplicates[ j ], 1 );
1879		}
1880	}
1881
1882	return results;
1883};
1884
1885/**
1886 * Utility function for retrieving the text value of an array of DOM nodes
1887 * @param {Array|Element} elem
1888 */
1889getText = Sizzle.getText = function( elem ) {
1890	var node,
1891		ret = "",
1892		i = 0,
1893		nodeType = elem.nodeType;
1894
1895	if ( !nodeType ) {
1896		// If no nodeType, this is expected to be an array
1897		for ( ; (node = elem[i]); i++ ) {
1898			// Do not traverse comment nodes
1899			ret += getText( node );
1900		}
1901	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1902		// Use textContent for elements
1903		// innerText usage removed for consistency of new lines (see #11153)
1904		if ( typeof elem.textContent === "string" ) {
1905			return elem.textContent;
1906		} else {
1907			// Traverse its children
1908			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1909				ret += getText( elem );
1910			}
1911		}
1912	} else if ( nodeType === 3 || nodeType === 4 ) {
1913		return elem.nodeValue;
1914	}
1915	// Do not include comment or processing instruction nodes
1916
1917	return ret;
1918};
1919
1920Expr = Sizzle.selectors = {
1921
1922	// Can be adjusted by the user
1923	cacheLength: 50,
1924
1925	createPseudo: markFunction,
1926
1927	match: matchExpr,
1928
1929	attrHandle: {},
1930
1931	find: {},
1932
1933	relative: {
1934		">": { dir: "parentNode", first: true },
1935		" ": { dir: "parentNode" },
1936		"+": { dir: "previousSibling", first: true },
1937		"~": { dir: "previousSibling" }
1938	},
1939
1940	preFilter: {
1941		"ATTR": function( match ) {
1942			match[1] = match[1].replace( runescape, funescape );
1943
1944			// Move the given value to match[3] whether quoted or unquoted
1945			match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape );
1946
1947			if ( match[2] === "~=" ) {
1948				match[3] = " " + match[3] + " ";
1949			}
1950
1951			return match.slice( 0, 4 );
1952		},
1953
1954		"CHILD": function( match ) {
1955			/* matches from matchExpr["CHILD"]
1956				1 type (only|nth|...)
1957				2 what (child|of-type)
1958				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1959				4 xn-component of xn+y argument ([+-]?\d*n|)
1960				5 sign of xn-component
1961				6 x of xn-component
1962				7 sign of y-component
1963				8 y of y-component
1964			*/
1965			match[1] = match[1].toLowerCase();
1966
1967			if ( match[1].slice( 0, 3 ) === "nth" ) {
1968				// nth-* requires argument
1969				if ( !match[3] ) {
1970					Sizzle.error( match[0] );
1971				}
1972
1973				// numeric x and y parameters for Expr.filter.CHILD
1974				// remember that false/true cast respectively to 0/1
1975				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1976				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1977
1978			// other types prohibit arguments
1979			} else if ( match[3] ) {
1980				Sizzle.error( match[0] );
1981			}
1982
1983			return match;
1984		},
1985
1986		"PSEUDO": function( match ) {
1987			var excess,
1988				unquoted = !match[5] && match[2];
1989
1990			if ( matchExpr["CHILD"].test( match[0] ) ) {
1991				return null;
1992			}
1993
1994			// Accept quoted arguments as-is
1995			if ( match[3] && match[4] !== undefined ) {
1996				match[2] = match[4];
1997
1998			// Strip excess characters from unquoted arguments
1999			} else if ( unquoted && rpseudo.test( unquoted ) &&
2000				// Get excess from tokenize (recursively)
2001				(excess = tokenize( unquoted, true )) &&
2002				// advance to the next closing parenthesis
2003				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
2004
2005				// excess is a negative index
2006				match[0] = match[0].slice( 0, excess );
2007				match[2] = unquoted.slice( 0, excess );
2008			}
2009
2010			// Return only captures needed by the pseudo filter method (type and argument)
2011			return match.slice( 0, 3 );
2012		}
2013	},
2014
2015	filter: {
2016
2017		"TAG": function( nodeNameSelector ) {
2018			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
2019			return nodeNameSelector === "*" ?
2020				function() { return true; } :
2021				function( elem ) {
2022					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
2023				};
2024		},
2025
2026		"CLASS": function( className ) {
2027			var pattern = classCache[ className + " " ];
2028
2029			return pattern ||
2030				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
2031				classCache( className, function( elem ) {
2032					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "" );
2033				});
2034		},
2035
2036		"ATTR": function( name, operator, check ) {
2037			return function( elem ) {
2038				var result = Sizzle.attr( elem, name );
2039
2040				if ( result == null ) {
2041					return operator === "!=";
2042				}
2043				if ( !operator ) {
2044					return true;
2045				}
2046
2047				result += "";
2048
2049				return operator === "=" ? result === check :
2050					operator === "!=" ? result !== check :
2051					operator === "^=" ? check && result.indexOf( check ) === 0 :
2052					operator === "*=" ? check && result.indexOf( check ) > -1 :
2053					operator === "$=" ? check && result.slice( -check.length ) === check :
2054					operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
2055					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
2056					false;
2057			};
2058		},
2059
2060		"CHILD": function( type, what, argument, first, last ) {
2061			var simple = type.slice( 0, 3 ) !== "nth",
2062				forward = type.slice( -4 ) !== "last",
2063				ofType = what === "of-type";
2064
2065			return first === 1 && last === 0 ?
2066
2067				// Shortcut for :nth-*(n)
2068				function( elem ) {
2069					return !!elem.parentNode;
2070				} :
2071
2072				function( elem, context, xml ) {
2073					var cache, outerCache, node, diff, nodeIndex, start,
2074						dir = simple !== forward ? "nextSibling" : "previousSibling",
2075						parent = elem.parentNode,
2076						name = ofType && elem.nodeName.toLowerCase(),
2077						useCache = !xml && !ofType;
2078
2079					if ( parent ) {
2080
2081						// :(first|last|only)-(child|of-type)
2082						if ( simple ) {
2083							while ( dir ) {
2084								node = elem;
2085								while ( (node = node[ dir ]) ) {
2086									if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
2087										return false;
2088									}
2089								}
2090								// Reverse direction for :only-* (if we haven't yet done so)
2091								start = dir = type === "only" && !start && "nextSibling";
2092							}
2093							return true;
2094						}
2095
2096						start = [ forward ? parent.firstChild : parent.lastChild ];
2097
2098						// non-xml :nth-child(...) stores cache data on `parent`
2099						if ( forward && useCache ) {
2100							// Seek `elem` from a previously-cached index
2101							outerCache = parent[ expando ] || (parent[ expando ] = {});
2102							cache = outerCache[ type ] || [];
2103							nodeIndex = cache[0] === dirruns && cache[1];
2104							diff = cache[0] === dirruns && cache[2];
2105							node = nodeIndex && parent.childNodes[ nodeIndex ];
2106
2107							while ( (node = ++nodeIndex && node && node[ dir ] ||
2108
2109								// Fallback to seeking `elem` from the start
2110								(diff = nodeIndex = 0) || start.pop()) ) {
2111
2112								// When found, cache indexes on `parent` and break
2113								if ( node.nodeType === 1 && ++diff && node === elem ) {
2114									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
2115									break;
2116								}
2117							}
2118
2119						// Use previously-cached element index if available
2120						} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
2121							diff = cache[1];
2122
2123						// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
2124						} else {
2125							// Use the same loop as above to seek `elem` from the start
2126							while ( (node = ++nodeIndex && node && node[ dir ] ||
2127								(diff = nodeIndex = 0) || start.pop()) ) {
2128
2129								if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
2130									// Cache the index of each encountered element
2131									if ( useCache ) {
2132										(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
2133									}
2134
2135									if ( node === elem ) {
2136										break;
2137									}
2138								}
2139							}
2140						}
2141
2142						// Incorporate the offset, then check against cycle size
2143						diff -= last;
2144						return diff === first || ( diff % first === 0 && diff / first >= 0 );
2145					}
2146				};
2147		},
2148
2149		"PSEUDO": function( pseudo, argument ) {
2150			// pseudo-class names are case-insensitive
2151			// http://www.w3.org/TR/selectors/#pseudo-classes
2152			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2153			// Remember that setFilters inherits from pseudos
2154			var args,
2155				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2156					Sizzle.error( "unsupported pseudo: " + pseudo );
2157
2158			// The user may use createPseudo to indicate that
2159			// arguments are needed to create the filter function
2160			// just as Sizzle does
2161			if ( fn[ expando ] ) {
2162				return fn( argument );
2163			}
2164
2165			// But maintain support for old signatures
2166			if ( fn.length > 1 ) {
2167				args = [ pseudo, pseudo, "", argument ];
2168				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2169					markFunction(function( seed, matches ) {
2170						var idx,
2171							matched = fn( seed, argument ),
2172							i = matched.length;
2173						while ( i-- ) {
2174							idx = indexOf.call( seed, matched[i] );
2175							seed[ idx ] = !( matches[ idx ] = matched[i] );
2176						}
2177					}) :
2178					function( elem ) {
2179						return fn( elem, 0, args );
2180					};
2181			}
2182
2183			return fn;
2184		}
2185	},
2186
2187	pseudos: {
2188		// Potentially complex pseudos
2189		"not": markFunction(function( selector ) {
2190			// Trim the selector passed to compile
2191			// to avoid treating leading and trailing
2192			// spaces as combinators
2193			var input = [],
2194				results = [],
2195				matcher = compile( selector.replace( rtrim, "$1" ) );
2196
2197			return matcher[ expando ] ?
2198				markFunction(function( seed, matches, context, xml ) {
2199					var elem,
2200						unmatched = matcher( seed, null, xml, [] ),
2201						i = seed.length;
2202
2203					// Match elements unmatched by `matcher`
2204					while ( i-- ) {
2205						if ( (elem = unmatched[i]) ) {
2206							seed[i] = !(matches[i] = elem);
2207						}
2208					}
2209				}) :
2210				function( elem, context, xml ) {
2211					input[0] = elem;
2212					matcher( input, null, xml, results );
2213					return !results.pop();
2214				};
2215		}),
2216
2217		"has": markFunction(function( selector ) {
2218			return function( elem ) {
2219				return Sizzle( selector, elem ).length > 0;
2220			};
2221		}),
2222
2223		"contains": markFunction(function( text ) {
2224			return function( elem ) {
2225				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
2226			};
2227		}),
2228
2229		// "Whether an element is represented by a :lang() selector
2230		// is based solely on the element's language value
2231		// being equal to the identifier C,
2232		// or beginning with the identifier C immediately followed by "-".
2233		// The matching of C against the element's language value is performed case-insensitively.
2234		// The identifier C does not have to be a valid language name."
2235		// http://www.w3.org/TR/selectors/#lang-pseudo
2236		"lang": markFunction( function( lang ) {
2237			// lang value must be a valid identifier
2238			if ( !ridentifier.test(lang || "") ) {
2239				Sizzle.error( "unsupported lang: " + lang );
2240			}
2241			lang = lang.replace( runescape, funescape ).toLowerCase();
2242			return function( elem ) {
2243				var elemLang;
2244				do {
2245					if ( (elemLang = documentIsHTML ?
2246						elem.lang :
2247						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
2248
2249						elemLang = elemLang.toLowerCase();
2250						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2251					}
2252				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
2253				return false;
2254			};
2255		}),
2256
2257		// Miscellaneous
2258		"target": function( elem ) {
2259			var hash = window.location && window.location.hash;
2260			return hash && hash.slice( 1 ) === elem.id;
2261		},
2262
2263		"root": function( elem ) {
2264			return elem === docElem;
2265		},
2266
2267		"focus": function( elem ) {
2268			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
2269		},
2270
2271		// Boolean properties
2272		"enabled": function( elem ) {
2273			return elem.disabled === false;
2274		},
2275
2276		"disabled": function( elem ) {
2277			return elem.disabled === true;
2278		},
2279
2280		"checked": function( elem ) {
2281			// In CSS3, :checked should return both checked and selected elements
2282			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2283			var nodeName = elem.nodeName.toLowerCase();
2284			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
2285		},
2286
2287		"selected": function( elem ) {
2288			// Accessing this property makes selected-by-default
2289			// options in Safari work properly
2290			if ( elem.parentNode ) {
2291				elem.parentNode.selectedIndex;
2292			}
2293
2294			return elem.selected === true;
2295		},
2296
2297		// Contents
2298		"empty": function( elem ) {
2299			// http://www.w3.org/TR/selectors/#empty-pseudo
2300			// :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),
2301			//   not comment, processing instructions, or others
2302			// Thanks to Diego Perini for the nodeName shortcut
2303			//   Greater than "@" means alpha characters (specifically not starting with "#" or "?")
2304			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2305				if ( elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4 ) {
2306					return false;
2307				}
2308			}
2309			return true;
2310		},
2311
2312		"parent": function( elem ) {
2313			return !Expr.pseudos["empty"]( elem );
2314		},
2315
2316		// Element/input types
2317		"header": function( elem ) {
2318			return rheader.test( elem.nodeName );
2319		},
2320
2321		"input": function( elem ) {
2322			return rinputs.test( elem.nodeName );
2323		},
2324
2325		"button": function( elem ) {
2326			var name = elem.nodeName.toLowerCase();
2327			return name === "input" && elem.type === "button" || name === "button";
2328		},
2329
2330		"text": function( elem ) {
2331			var attr;
2332			// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
2333			// use getAttribute instead to test this case
2334			return elem.nodeName.toLowerCase() === "input" &&
2335				elem.type === "text" &&
2336				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === elem.type );
2337		},
2338
2339		// Position-in-collection
2340		"first": createPositionalPseudo(function() {
2341			return [ 0 ];
2342		}),
2343
2344		"last": createPositionalPseudo(function( matchIndexes, length ) {
2345			return [ length - 1 ];
2346		}),
2347
2348		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
2349			return [ argument < 0 ? argument + length : argument ];
2350		}),
2351
2352		"even": createPositionalPseudo(function( matchIndexes, length ) {
2353			var i = 0;
2354			for ( ; i < length; i += 2 ) {
2355				matchIndexes.push( i );
2356			}
2357			return matchIndexes;
2358		}),
2359
2360		"odd": createPositionalPseudo(function( matchIndexes, length ) {
2361			var i = 1;
2362			for ( ; i < length; i += 2 ) {
2363				matchIndexes.push( i );
2364			}
2365			return matchIndexes;
2366		}),
2367
2368		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2369			var i = argument < 0 ? argument + length : argument;
2370			for ( ; --i >= 0; ) {
2371				matchIndexes.push( i );
2372			}
2373			return matchIndexes;
2374		}),
2375
2376		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2377			var i = argument < 0 ? argument + length : argument;
2378			for ( ; ++i < length; ) {
2379				matchIndexes.push( i );
2380			}
2381			return matchIndexes;
2382		})
2383	}
2384};
2385
2386Expr.pseudos["nth"] = Expr.pseudos["eq"];
2387
2388// Add button/input type pseudos
2389for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2390	Expr.pseudos[ i ] = createInputPseudo( i );
2391}
2392for ( i in { submit: true, reset: true } ) {
2393	Expr.pseudos[ i ] = createButtonPseudo( i );
2394}
2395
2396// Easy API for creating new setFilters
2397function setFilters() {}
2398setFilters.prototype = Expr.filters = Expr.pseudos;
2399Expr.setFilters = new setFilters();
2400
2401function tokenize( selector, parseOnly ) {
2402	var matched, match, tokens, type,
2403		soFar, groups, preFilters,
2404		cached = tokenCache[ selector + " " ];
2405
2406	if ( cached ) {
2407		return parseOnly ? 0 : cached.slice( 0 );
2408	}
2409
2410	soFar = selector;
2411	groups = [];
2412	preFilters = Expr.preFilter;
2413
2414	while ( soFar ) {
2415
2416		// Comma and first run
2417		if ( !matched || (match = rcomma.exec( soFar )) ) {
2418			if ( match ) {
2419				// Don't consume trailing commas as valid
2420				soFar = soFar.slice( match[0].length ) || soFar;
2421			}
2422			groups.push( tokens = [] );
2423		}
2424
2425		matched = false;
2426
2427		// Combinators
2428		if ( (match = rcombinators.exec( soFar )) ) {
2429			matched = match.shift();
2430			tokens.push({
2431				value: matched,
2432				// Cast descendant combinators to space
2433				type: match[0].replace( rtrim, " " )
2434			});
2435			soFar = soFar.slice( matched.length );
2436		}
2437
2438		// Filters
2439		for ( type in Expr.filter ) {
2440			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2441				(match = preFilters[ type ]( match ))) ) {
2442				matched = match.shift();
2443				tokens.push({
2444					value: matched,
2445					type: type,
2446					matches: match
2447				});
2448				soFar = soFar.slice( matched.length );
2449			}
2450		}
2451
2452		if ( !matched ) {
2453			break;
2454		}
2455	}
2456
2457	// Return the length of the invalid excess
2458	// if we're just parsing
2459	// Otherwise, throw an error or return tokens
2460	return parseOnly ?
2461		soFar.length :
2462		soFar ?
2463			Sizzle.error( selector ) :
2464			// Cache the tokens
2465			tokenCache( selector, groups ).slice( 0 );
2466}
2467
2468function toSelector( tokens ) {
2469	var i = 0,
2470		len = tokens.length,
2471		selector = "";
2472	for ( ; i < len; i++ ) {
2473		selector += tokens[i].value;
2474	}
2475	return selector;
2476}
2477
2478function addCombinator( matcher, combinator, base ) {
2479	var dir = combinator.dir,
2480		checkNonElements = base && dir === "parentNode",
2481		doneName = done++;
2482
2483	return combinator.first ?
2484		// Check against closest ancestor/preceding element
2485		function( elem, context, xml ) {
2486			while ( (elem = elem[ dir ]) ) {
2487				if ( elem.nodeType === 1 || checkNonElements ) {
2488					return matcher( elem, context, xml );
2489				}
2490			}
2491		} :
2492
2493		// Check against all ancestor/preceding elements
2494		function( elem, context, xml ) {
2495			var data, cache, outerCache,
2496				dirkey = dirruns + " " + doneName;
2497
2498			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
2499			if ( xml ) {
2500				while ( (elem = elem[ dir ]) ) {
2501					if ( elem.nodeType === 1 || checkNonElements ) {
2502						if ( matcher( elem, context, xml ) ) {
2503							return true;
2504						}
2505					}
2506				}
2507			} else {
2508				while ( (elem = elem[ dir ]) ) {
2509					if ( elem.nodeType === 1 || checkNonElements ) {
2510						outerCache = elem[ expando ] || (elem[ expando ] = {});
2511						if ( (cache = outerCache[ dir ]) && cache[0] === dirkey ) {
2512							if ( (data = cache[1]) === true || data === cachedruns ) {
2513								return data === true;
2514							}
2515						} else {
2516							cache = outerCache[ dir ] = [ dirkey ];
2517							cache[1] = matcher( elem, context, xml ) || cachedruns;
2518							if ( cache[1] === true ) {
2519								return true;
2520							}
2521						}
2522					}
2523				}
2524			}
2525		};
2526}
2527
2528function elementMatcher( matchers ) {
2529	return matchers.length > 1 ?
2530		function( elem, context, xml ) {
2531			var i = matchers.length;
2532			while ( i-- ) {
2533				if ( !matchers[i]( elem, context, xml ) ) {
2534					return false;
2535				}
2536			}
2537			return true;
2538		} :
2539		matchers[0];
2540}
2541
2542function condense( unmatched, map, filter, context, xml ) {
2543	var elem,
2544		newUnmatched = [],
2545		i = 0,
2546		len = unmatched.length,
2547		mapped = map != null;
2548
2549	for ( ; i < len; i++ ) {
2550		if ( (elem = unmatched[i]) ) {
2551			if ( !filter || filter( elem, context, xml ) ) {
2552				newUnmatched.push( elem );
2553				if ( mapped ) {
2554					map.push( i );
2555				}
2556			}
2557		}
2558	}
2559
2560	return newUnmatched;
2561}
2562
2563function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {

2564	if ( postFilter && !postFilter[ expando ] ) {
2565		postFilter = setMatcher( postFilter );
2566	}
2567	if ( postFinder && !postFinder[ expando ] ) {
2568		postFinder = setMatcher( postFinder, postSelector );
2569	}
2570	return markFunction(function( seed, results, context, xml ) {
2571		var temp, i, elem,
2572			preMap = [],
2573			postMap = [],
2574			preexisting = results.length,
2575
2576			// Get initial elements from seed or context
2577			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2578
2579			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2580			matcherIn = preFilter && ( seed || !selector ) ?
2581				condense( elems, preMap, preFilter, context, xml ) :
2582				elems,
2583
2584			matcherOut = matcher ?
2585				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2586				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2587
2588					// ...intermediate processing is necessary
2589					[] :
2590
2591					// ...otherwise use results directly
2592					results :
2593				matcherIn;
2594
2595		// Find primary matches
2596		if ( matcher ) {
2597			matcher( matcherIn, matcherOut, context, xml );
2598		}
2599
2600		// Apply postFilter
2601		if ( postFilter ) {
2602			temp = condense( matcherOut, postMap );
2603			postFilter( temp, [], context, xml );
2604
2605			// Un-match failing elements by moving them back to matcherIn
2606			i = temp.length;
2607			while ( i-- ) {
2608				if ( (elem = temp[i]) ) {
2609					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2610				}
2611			}
2612		}
2613
2614		if ( seed ) {
2615			if ( postFinder || preFilter ) {
2616				if ( postFinder ) {
2617					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2618					temp = [];
2619					i = matcherOut.length;
2620					while ( i-- ) {
2621						if ( (elem = matcherOut[i]) ) {
2622							// Restore matcherIn since elem is not yet a final match
2623							temp.push( (matcherIn[i] = elem) );
2624						}
2625					}
2626					postFinder( null, (matcherOut = []), temp, xml );
2627				}
2628
2629				// Move matched elements from seed to results to keep them synchronized
2630				i = matcherOut.length;
2631				while ( i-- ) {
2632					if ( (elem = matcherOut[i]) &&
2633						(temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {
2634
2635						seed[temp] = !(results[temp] = elem);
2636					}
2637				}
2638			}
2639
2640		// Add elements to results, through postFinder if defined
2641		} else {
2642			matcherOut = condense(
2643				matcherOut === results ?
2644					matcherOut.splice( preexisting, matcherOut.length ) :
2645					matcherOut
2646			);
2647			if ( postFinder ) {
2648				postFinder( null, results, matcherOut, xml );
2649			} else {
2650				push.apply( results, matcherOut );
2651			}
2652		}
2653	});
2654}
2655
2656function matcherFromTokens( tokens ) {
2657	var checkContext, matcher, j,
2658		len = tokens.length,
2659		leadingRelative = Expr.relative[ tokens[0].type ],
2660		implicitRelative = leadingRelative || Expr.relative[" "],
2661		i = leadingRelative ? 1 : 0,
2662
2663		// The foundational matcher ensures that elements are reachable from top-level context(s)
2664		matchContext = addCombinator( function( elem ) {
2665			return elem === checkContext;
2666		}, implicitRelative, true ),
2667		matchAnyContext = addCombinator( function( elem ) {
2668			return indexOf.call( checkContext, elem ) > -1;
2669		}, implicitRelative, true ),
2670		matchers = [ function( elem, context, xml ) {
2671			return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2672				(checkContext = context).nodeType ?
2673					matchContext( elem, context, xml ) :
2674					matchAnyContext( elem, context, xml ) );
2675		} ];
2676
2677	for ( ; i < len; i++ ) {
2678		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2679			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2680		} else {
2681			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2682
2683			// Return special upon seeing a positional matcher
2684			if ( matcher[ expando ] ) {
2685				// Find the next relative operator (if any) for proper handling
2686				j = ++i;
2687				for ( ; j < len; j++ ) {
2688					if ( Expr.relative[ tokens[j].type ] ) {
2689						break;
2690					}
2691				}
2692				return setMatcher(
2693					i > 1 && elementMatcher( matchers ),
2694					i > 1 && toSelector(
2695						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2696						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2697					).replace( rtrim, "$1" ),
2698					matcher,
2699					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2700					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2701					j < len && toSelector( tokens )
2702				);
2703			}
2704			matchers.push( matcher );
2705		}
2706	}
2707
2708	return elementMatcher( matchers );
2709}
2710
2711function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2712	// A counter to specify which element is currently being matched
2713	var matcherCachedRuns = 0,
2714		bySet = setMatchers.length > 0,
2715		byElement = elementMatchers.length > 0,
2716		superMatcher = function( seed, context, xml, results, expandContext ) {
2717			var elem, j, matcher,
2718				setMatched = [],
2719				matchedCount = 0,
2720				i = "0",
2721				unmatched = seed && [],
2722				outermost = expandContext != null,
2723				contextBackup = outermostContext,
2724				// We must always have either seed elements or context
2725				elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ),
2726				// Use integer dirruns iff this is the outermost matcher
2727				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1);
2728
2729			if ( outermost ) {
2730				outermostContext = context !== document && context;
2731				cachedruns = matcherCachedRuns;
2732			}
2733
2734			// Add elements passing elementMatchers directly to results
2735			// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
2736			for ( ; (elem = elems[i]) != null; i++ ) {
2737				if ( byElement && elem ) {
2738					j = 0;
2739					while ( (matcher = elementMatchers[j++]) ) {
2740						if ( matcher( elem, context, xml ) ) {
2741							results.push( elem );
2742							break;
2743						}
2744					}
2745					if ( outermost ) {
2746						dirruns = dirrunsUnique;
2747						cachedruns = ++matcherCachedRuns;
2748					}
2749				}
2750
2751				// Track unmatched elements for set filters
2752				if ( bySet ) {
2753					// They will have gone through all possible matchers
2754					if ( (elem = !matcher && elem) ) {
2755						matchedCount--;
2756					}
2757
2758					// Lengthen the array for every element, matched or not
2759					if ( seed ) {
2760						unmatched.push( elem );
2761					}
2762				}
2763			}
2764
2765			// Apply set filters to unmatched elements
2766			matchedCount += i;
2767			if ( bySet && i !== matchedCount ) {
2768				j = 0;
2769				while ( (matcher = setMatchers[j++]) ) {
2770					matcher( unmatched, setMatched, context, xml );
2771				}
2772
2773				if ( seed ) {
2774					// Reintegrate element matches to eliminate the need for sorting
2775					if ( matchedCount > 0 ) {
2776						while ( i-- ) {
2777							if ( !(unmatched[i] || setMatched[i]) ) {
2778								setMatched[i] = pop.call( results );
2779							}
2780						}
2781					}
2782
2783					// Discard index placeholder values to get only actual matches
2784					setMatched = condense( setMatched );
2785				}
2786
2787				// Add matches to results
2788				push.apply( results, setMatched );
2789
2790				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2791				if ( outermost && !seed && setMatched.length > 0 &&
2792					( matchedCount + setMatchers.length ) > 1 ) {
2793
2794					Sizzle.uniqueSort( results );
2795				}
2796			}
2797
2798			// Override manipulation of globals by nested matchers
2799			if ( outermost ) {
2800				dirruns = dirrunsUnique;
2801				outermostContext = contextBackup;
2802			}
2803
2804			return unmatched;
2805		};
2806
2807	return bySet ?
2808		markFunction( superMatcher ) :
2809		superMatcher;
2810}
2811
2812compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) {
2813	var i,
2814		setMatchers = [],
2815		elementMatchers = [],
2816		cached = compilerCache[ selector + " " ];
2817
2818	if ( !cached ) {
2819		// Generate a function of recursive functions that can be used to check each element
2820		if ( !group ) {
2821			group = tokenize( selector );
2822		}
2823		i = group.length;
2824		while ( i-- ) {
2825			cached = matcherFromTokens( group[i] );
2826			if ( cached[ expando ] ) {
2827				setMatchers.push( cached );
2828			} else {
2829				elementMatchers.push( cached );
2830			}
2831		}
2832
2833		// Cache the compiled function
2834		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2835	}
2836	return cached;
2837};