https://racemob.com/assets/searches_fast_bundle-f4280bc76f5a450a4b…45ca5e3849412a740973fb530c314df2dffbb898.js

1/*!
2 * jQuery JavaScript Library v3.5.1
3 * https://jquery.com/
4 *
5 * Includes Sizzle.js
6 * https://sizzlejs.com/
7 *
8 * Copyright JS Foundation and other contributors
9 * Released under the MIT license
10 * https://jquery.org/license
11 *
12 * Date: 2020-05-04T22:49Z
13 */
14
15( function( global, factory ) {
16
17	"use strict";
18
19	if ( typeof module === "object" && typeof module.exports === "object" ) {
20
21		// For CommonJS and CommonJS-like environments where a proper `window`
22		// is present, execute the factory and get jQuery.
23		// For environments that do not have a `window` with a `document`
24		// (such as Node.js), expose a factory as module.exports.
25		// This accentuates the need for the creation of a real `window`.
26		// e.g. var jQuery = require("jquery")(window);
27		// See ticket #14549 for more info.
28		module.exports = global.document ?
29			factory( global, true ) :
30			function( w ) {
31				if ( !w.document ) {
32					throw new Error( "jQuery requires a window with a document" );
33				}
34				return factory( w );
35			};
36	} else {
37		factory( global );
38	}
39
40// Pass this if window is not defined yet
41} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
42
43// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
44// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
45// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
46// enough that all such attempts are guarded in a try block.
47"use strict";
48
49var arr = [];
50
51var getProto = Object.getPrototypeOf;
52
53var slice = arr.slice;
54
55var flat = arr.flat ? function( array ) {
56	return arr.flat.call( array );
57} : function( array ) {
58	return arr.concat.apply( [], array );
59};
60
61
62var push = arr.push;
63
64var indexOf = arr.indexOf;
65
66var class2type = {};
67
68var toString = class2type.toString;
69
70var hasOwn = class2type.hasOwnProperty;
71
72var fnToString = hasOwn.toString;
73
74var ObjectFunctionString = fnToString.call( Object );
75
76var support = {};
77
78var isFunction = function isFunction( obj ) {
79
80      // Support: Chrome <=57, Firefox <=52
81      // In some browsers, typeof returns "function" for HTML <object> elements
82      // (i.e., `typeof document.createElement( "object" ) === "function"`).
83      // We don't want to classify *any* DOM node as a function.
84      return typeof obj === "function" && typeof obj.nodeType !== "number";
85  };
86
87
88var isWindow = function isWindow( obj ) {
89		return obj != null && obj === obj.window;
90	};
91
92
93var document = window.document;
94
95
96
97	var preservedScriptAttributes = {
98		type: true,
99		src: true,
100		nonce: true,
101		noModule: true
102	};
103
104	function DOMEval( code, node, doc ) {
105		doc = doc || document;
106
107		var i, val,
108			script = doc.createElement( "script" );
109
110		script.text = code;
111		if ( node ) {
112			for ( i in preservedScriptAttributes ) {
113
114				// Support: Firefox 64+, Edge 18+
115				// Some browsers don't support the "nonce" property on scripts.
116				// On the other hand, just using `getAttribute` is not enough as
117				// the `nonce` attribute is reset to an empty string whenever it
118				// becomes browsing-context connected.
119				// See https://github.com/whatwg/html/issues/2369
120				// See https://html.spec.whatwg.org/#nonce-attributes
121				// The `node.getAttribute` check was added for the sake of
122				// `jQuery.globalEval` so that it can fake a nonce-containing node
123				// via an object.
124				val = node[ i ] || node.getAttribute && node.getAttribute( i );
125				if ( val ) {
126					script.setAttribute( i, val );
127				}
128			}
129		}
130		doc.head.appendChild( script ).parentNode.removeChild( script );
131	}
132
133
134function toType( obj ) {
135	if ( obj == null ) {
136		return obj + "";
137	}
138
139	// Support: Android <=2.3 only (functionish RegExp)
140	return typeof obj === "object" || typeof obj === "function" ?
141		class2type[ toString.call( obj ) ] || "object" :
142		typeof obj;
143}
144/* global Symbol */
145// Defining this global in .eslintrc.json would create a danger of using the global
146// unguarded in another place, it seems safer to define global only for this module
147
148
149
150var
151	version = "3.5.1",
152
153	// Define a local copy of jQuery
154	jQuery = function( selector, context ) {
155
156		// The jQuery object is actually just the init constructor 'enhanced'
157		// Need init if jQuery is called (just allow error to be thrown if not included)
158		return new jQuery.fn.init( selector, context );
159	};
160
161jQuery.fn = jQuery.prototype = {
162
163	// The current version of jQuery being used
164	jquery: version,
165
166	constructor: jQuery,
167
168	// The default length of a jQuery object is 0
169	length: 0,
170
171	toArray: function() {
172		return slice.call( this );
173	},
174
175	// Get the Nth element in the matched element set OR
176	// Get the whole matched element set as a clean array
177	get: function( num ) {
178
179		// Return all the elements in a clean array
180		if ( num == null ) {
181			return slice.call( this );
182		}
183
184		// Return just the one element from the set
185		return num < 0 ? this[ num + this.length ] : this[ num ];
186	},
187
188	// Take an array of elements and push it onto the stack
189	// (returning the new matched element set)
190	pushStack: function( elems ) {
191
192		// Build a new jQuery matched element set
193		var ret = jQuery.merge( this.constructor(), elems );
194
195		// Add the old object onto the stack (as a reference)

196		ret.prevObject = this;
197
198		// Return the newly-formed element set
199		return ret;
200	},
201
202	// Execute a callback for every element in the matched set.
203	each: function( callback ) {
204		return jQuery.each( this, callback );
205	},
206
207	map: function( callback ) {
208		return this.pushStack( jQuery.map( this, function( elem, i ) {
209			return callback.call( elem, i, elem );
210		} ) );
211	},
212
213	slice: function() {
214		return this.pushStack( slice.apply( this, arguments ) );
215	},
216
217	first: function() {
218		return this.eq( 0 );
219	},
220
221	last: function() {
222		return this.eq( -1 );
223	},
224
225	even: function() {
226		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
227			return ( i + 1 ) % 2;
228		} ) );
229	},
230
231	odd: function() {
232		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
233			return i % 2;
234		} ) );
235	},
236
237	eq: function( i ) {
238		var len = this.length,
239			j = +i + ( i < 0 ? len : 0 );
240		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
241	},
242
243	end: function() {
244		return this.prevObject || this.constructor();
245	},
246
247	// For internal use only.
248	// Behaves like an Array's method, not like a jQuery method.
249	push: push,
250	sort: arr.sort,
251	splice: arr.splice
252};
253
254jQuery.extend = jQuery.fn.extend = function() {
255	var options, name, src, copy, copyIsArray, clone,
256		target = arguments[ 0 ] || {},
257		i = 1,
258		length = arguments.length,
259		deep = false;
260
261	// Handle a deep copy situation
262	if ( typeof target === "boolean" ) {
263		deep = target;
264
265		// Skip the boolean and the target
266		target = arguments[ i ] || {};
267		i++;
268	}
269
270	// Handle case when target is a string or something (possible in deep copy)
271	if ( typeof target !== "object" && !isFunction( target ) ) {
272		target = {};
273	}
274
275	// Extend jQuery itself if only one argument is passed
276	if ( i === length ) {
277		target = this;
278		i--;
279	}
280
281	for ( ; i < length; i++ ) {
282
283		// Only deal with non-null/undefined values
284		if ( ( options = arguments[ i ] ) != null ) {
285
286			// Extend the base object
287			for ( name in options ) {
288				copy = options[ name ];
289
290				// Prevent Object.prototype pollution
291				// Prevent never-ending loop
292				if ( name === "__proto__" || target === copy ) {
293					continue;
294				}
295
296				// Recurse if we're merging plain objects or arrays
297				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
298					( copyIsArray = Array.isArray( copy ) ) ) ) {
299					src = target[ name ];
300
301					// Ensure proper type for the source value
302					if ( copyIsArray && !Array.isArray( src ) ) {
303						clone = [];
304					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
305						clone = {};
306					} else {
307						clone = src;
308					}
309					copyIsArray = false;
310
311					// Never move original objects, clone them
312					target[ name ] = jQuery.extend( deep, clone, copy );
313
314				// Don't bring in undefined values
315				} else if ( copy !== undefined ) {
316					target[ name ] = copy;
317				}
318			}
319		}
320	}
321
322	// Return the modified object
323	return target;
324};
325
326jQuery.extend( {
327
328	// Unique for each copy of jQuery on the page
329	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
330
331	// Assume jQuery is ready without the ready module
332	isReady: true,
333
334	error: function( msg ) {
335		throw new Error( msg );
336	},
337
338	noop: function() {},
339
340	isPlainObject: function( obj ) {
341		var proto, Ctor;
342
343		// Detect obvious negatives
344		// Use toString instead of jQuery.type to catch host objects
345		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
346			return false;
347		}
348
349		proto = getProto( obj );
350
351		// Objects with no prototype (e.g., `Object.create( null )`) are plain
352		if ( !proto ) {
353			return true;
354		}
355
356		// Objects with prototype are plain iff they were constructed by a global Object function
357		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
358		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
359	},
360
361	isEmptyObject: function( obj ) {
362		var name;
363
364		for ( name in obj ) {
365			return false;
366		}
367		return true;
368	},
369
370	// Evaluates a script in a provided context; falls back to the global one
371	// if not specified.
372	globalEval: function( code, options, doc ) {
373		DOMEval( code, { nonce: options && options.nonce }, doc );
374	},
375
376	each: function( obj, callback ) {
377		var length, i = 0;
378
379		if ( isArrayLike( obj ) ) {
380			length = obj.length;
381			for ( ; i < length; i++ ) {
382				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
383					break;
384				}
385			}
386		} else {
387			for ( i in obj ) {
388				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
389					break;
390				}
391			}
392		}
393
394		return obj;
395	},
396
397	// results is for internal usage only
398	makeArray: function( arr, results ) {
399		var ret = results || [];
400
401		if ( arr != null ) {
402			if ( isArrayLike( Object( arr ) ) ) {
403				jQuery.merge( ret,
404					typeof arr === "string" ?
405					[ arr ] : arr
406				);
407			} else {
408				push.call( ret, arr );
409			}
410		}
411
412		return ret;
413	},
414
415	inArray: function( elem, arr, i ) {
416		return arr == null ? -1 : indexOf.call( arr, elem, i );
417	},
418
419	// Support: Android <=4.0 only, PhantomJS 1 only
420	// push.apply(_, arraylike) throws on ancient WebKit
421	merge: function( first, second ) {
422		var len = +second.length,
423			j = 0,
424			i = first.length;
425
426		for ( ; j < len; j++ ) {
427			first[ i++ ] = second[ j ];
428		}
429
430		first.length = i;
431
432		return first;
433	},
434
435	grep: function( elems, callback, invert ) {
436		var callbackInverse,
437			matches = [],
438			i = 0,
439			length = elems.length,
440			callbackExpect = !invert;
441
442		// Go through the array, only saving the items
443		// that pass the validator function
444		for ( ; i < length; i++ ) {
445			callbackInverse = !callback( elems[ i ], i );
446			if ( callbackInverse !== callbackExpect ) {
447				matches.push( elems[ i ] );
448			}
449		}
450
451		return matches;
452	},
453
454	// arg is for internal usage only
455	map: function( elems, callback, arg ) {
456		var length, value,
457			i = 0,
458			ret = [];
459
460		// Go through the array, translating each of the items to their new values
461		if ( isArrayLike( elems ) ) {
462			length = elems.length;
463			for ( ; i < length; i++ ) {
464				value = callback( elems[ i ], i, arg );
465
466				if ( value != null ) {

467					ret.push( value );
468				}
469			}
470
471		// Go through every key on the object,
472		} else {
473			for ( i in elems ) {
474				value = callback( elems[ i ], i, arg );
475
476				if ( value != null ) {
477					ret.push( value );
478				}
479			}
480		}
481
482		// Flatten any nested arrays
483		return flat( ret );
484	},
485
486	// A global GUID counter for objects
487	guid: 1,
488
489	// jQuery.support is not used in Core but other projects attach their
490	// properties to it so it needs to exist.
491	support: support
492} );
493
494if ( typeof Symbol === "function" ) {
495	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
496}
497
498// Populate the class2type map
499jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
500function( _i, name ) {
501	class2type[ "[object " + name + "]" ] = name.toLowerCase();
502} );
503
504function isArrayLike( obj ) {
505
506	// Support: real iOS 8.2 only (not reproducible in simulator)
507	// `in` check used to prevent JIT error (gh-2145)
508	// hasOwn isn't used here due to false negatives
509	// regarding Nodelist length in IE
510	var length = !!obj && "length" in obj && obj.length,
511		type = toType( obj );
512
513	if ( isFunction( obj ) || isWindow( obj ) ) {
514		return false;
515	}
516
517	return type === "array" || length === 0 ||
518		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
519}
520var Sizzle =
521/*!
522 * Sizzle CSS Selector Engine v2.3.5
523 * https://sizzlejs.com/
524 *
525 * Copyright JS Foundation and other contributors
526 * Released under the MIT license
527 * https://js.foundation/
528 *
529 * Date: 2020-03-14

529
530 */
531( function( window ) {
532var i,
533	support,
534	Expr,
535	getText,
536	isXML,
537	tokenize,
538	compile,
539	select,
540	outermostContext,
541	sortInput,
542	hasDuplicate,
543
544	// Local document vars
545	setDocument,
546	document,
547	docElem,
548	documentIsHTML,
549	rbuggyQSA,
550	rbuggyMatches,
551	matches,
552	contains,
553
554	// Instance-specific data
555	expando = "sizzle" + 1 * new Date(),
556	preferredDoc = window.document,
557	dirruns = 0,
558	done = 0,
559	classCache = createCache(),
560	tokenCache = createCache(),
561	compilerCache = createCache(),
562	nonnativeSelectorCache = createCache(),
563	sortOrder = function( a, b ) {
564		if ( a === b ) {
565			hasDuplicate = true;
566		}
567		return 0;
568	},
569
570	// Instance methods
571	hasOwn = ( {} ).hasOwnProperty,
572	arr = [],
573	pop = arr.pop,
574	pushNative = arr.push,
575	push = arr.push,
576	slice = arr.slice,
577
578	// Use a stripped-down indexOf as it's faster than native
579	// https://jsperf.com/thor-indexof-vs-for/5
580	indexOf = function( list, elem ) {
581		var i = 0,
582			len = list.length;
583		for ( ; i < len; i++ ) {
584			if ( list[ i ] === elem ) {
585				return i;
586			}
587		}
588		return -1;
589	},
590
591	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
592		"ismap|loop|multiple|open|readonly|required|scoped",
593
594	// Regular expressions
595
596	// http://www.w3.org/TR/css3-selectors/#whitespace
597	whitespace = "[\\x20\\t\\r\\n\\f]",
598
599	// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
600	identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
601		"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
602
603	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
604	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
605
606		// Operator (capture 2)
607		"*([*^$|!~]?=)" + whitespace +
608
609		// "Attribute values must be CSS identifiers [capture 5]
610		// or strings [capture 3 or capture 4]"
611		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
612		whitespace + "*\\]",
613
614	pseudos = ":(" + identifier + ")(?:\\((" +
615
616		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
617		// 1. quoted (capture 3; capture 4 or capture 5)
618		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
619
620		// 2. simple (capture 6)
621		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
622
623		// 3. anything else (capture 2)
624		".*" +
625		")\\)|)",
626
627	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
628	rwhitespace = new RegExp( whitespace + "+", "g" ),
629	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
630		whitespace + "+$", "g" ),
631
632	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
633	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
634		"*" ),
635	rdescend = new RegExp( whitespace + "|>" ),
636
637	rpseudo = new RegExp( pseudos ),
638	ridentifier = new RegExp( "^" + identifier + "$" ),
639
640	matchExpr = {
641		"ID": new RegExp( "^#(" + identifier + ")" ),
642		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
643		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
644		"ATTR": new RegExp( "^" + attributes ),
645		"PSEUDO": new RegExp( "^" + pseudos ),
646		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
647			whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
648			whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
649		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
650
651		// For use in libraries implementing .is()
652		// We use this for POS matching in `select`
653		"needsContext": new RegExp( "^" + whitespace +
654			"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
655			"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
656	},
657
658	rhtml = /HTML$/i,
659	rinputs = /^(?:input|select|textarea|button)$/i,
660	rheader = /^h\d$/i,
661
662	rnative = /^[^{]+\{\s*\[native \w/,
663
664	// Easily-parseable/retrievable ID or TAG or CLASS selectors
665	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
666
667	rsibling = /[+~]/,
668
669	// CSS escapes
670	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
671	runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
672	funescape = function( escape, nonHex ) {
673		var high = "0x" + escape.slice( 1 ) - 0x10000;
674
675		return nonHex ?
676
677			// Strip the backslash prefix from a non-hex escape sequence
678			nonHex :
679
680			// Replace a hexadecimal escape sequence with the encoded Unicode code point
681			// Support: IE <=11+
682			// For values outside the Basic Multilingual Plane (BMP), manually construct a
683			// surrogate pair
684			high < 0 ?
685				String.fromCharCode( high + 0x10000 ) :
686				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
687	},
688
689	// CSS string/identifier serialization
690	// https://drafts.csswg.org/cssom/#common-serializing-idioms
691	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
692	fcssescape = function( ch, asCodePoint ) {
693		if ( asCodePoint ) {
694
695			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
696			if ( ch === "\0" ) {
697				return "\uFFFD";
698			}
699
700			// Control characters and (dependent upon position) numbers get escaped as code points
701			return ch.slice( 0, -1 ) + "\\" +
702				ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
703		}
704
705		// Other potentially-special ASCII characters get backslash-escaped
706		return "\\" + ch;
707	},
708
709	// Used for iframes
710	// See setDocument()
711	// Removing the function wrapper causes a "Permission Denied"
712	// error in IE
713	unloadHandler = function() {
714		setDocument();
715	},
716
717	inDisabledFieldset = addCombinator(
718		function( elem ) {
719			return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
720		},
721		{ dir: "parentNode", next: "legend" }
722	);
723
724// Optimize for push.apply( _, NodeList )
725try {
726	push.apply(
727		( arr = slice.call( preferredDoc.childNodes ) ),
728		preferredDoc.childNodes
729	);
730
731	// Support: Android<4.0
732	// Detect silently failing push.apply
733	// eslint-disable-next-line no-unused-expressions
734	arr[ preferredDoc.childNodes.length ].nodeType;
735} catch ( e ) {
736	push = { apply: arr.length ?
737
738		// Leverage slice if possible
739		function( target, els ) {
740			pushNative.apply( target, slice.call( els ) );
741		} :
742
743		// Support: IE<9
744		// Otherwise append directly
745		function( target, els ) {
746			var j = target.length,
747				i = 0;
748
749			// Can't trust NodeList.length
750			while ( ( target[ j++ ] = els[ i++ ] ) ) {}
751			target.length = j - 1;
752		}
753	};
754}
755
756function Sizzle( selector, context, results, seed ) {
757	var m, i, elem, nid, match, groups, newSelector,
758		newContext = context && context.ownerDocument,
759
760		// nodeType defaults to 9, since context defaults to document
761		nodeType = context ? context.nodeType : 9;
762
763	results = results || [];
764
765	// Return early from calls with invalid selector or context
766	if ( typeof selector !== "string" || !selector ||
767		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
768
769		return results;
770	}
771
772	// Try to shortcut find operations (as opposed to filters) in HTML documents
773	if ( !seed ) {
774		setDocument( context );
775		context = context || document;
776
777		if ( documentIsHTML ) {
778
779			// If the selector is sufficiently simple, try using a "get*By*" DOM method
780			// (excepting DocumentFragment context, where the methods don't exist)
781			if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
782
783				// ID selector
784				if ( ( m = match[ 1 ] ) ) {
785
786					// Document context
787					if ( nodeType === 9 ) {
788						if ( ( elem = context.getElementById( m ) ) ) {
789
790							// Support: IE, Opera, Webkit
791							// TODO: identify versions
792							// getElementById can match elements by name instead of ID
793							if ( elem.id === m ) {
794								results.push( elem );
795								return results;
796							}
797						} else {
798							return results;
799						}
800
801					// Element context
802					} else {
803
804						// Support: IE, Opera, Webkit
805						// TODO: identify versions
806						// getElementById can match elements by name instead of ID
807						if ( newContext && ( elem = newContext.getElementById( m ) ) &&
808							contains( context, elem ) &&
809							elem.id === m ) {
810
811							results.push( elem );
812							return results;
813						}
814					}
815
816				// Type selector
817				} else if ( match[ 2 ] ) {
818					push.apply( results, context.getElementsByTagName( selector ) );
819					return results;
820
821				// Class selector
822				} else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&
823					context.getElementsByClassName ) {
824
825					push.apply( results, context.getElementsByClassName( m ) );
826					return results;
827				}
828			}
829
830			// Take advantage of querySelectorAll
831			if ( support.qsa &&
832				!nonnativeSelectorCache[ selector + " " ] &&
833				( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&
834
835				// Support: IE 8 only
836				// Exclude object elements
837				( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) {
838
839				newSelector = selector;
840				newContext = context;
841
842				// qSA considers elements outside a scoping root when evaluating child or
843				// descendant combinators, which is not what we want.
844				// In such cases, we work around the behavior by prefixing every selector in the
845				// list with an ID selector referencing the scope context.
846				// The technique has to be used as well when a leading combinator is used
847				// as such selectors are not recognized by querySelectorAll.
848				// Thanks to Andrew Dupont for this technique.
849				if ( nodeType === 1 &&
850					( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
851
852					// Expand context for sibling selectors
853					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
854						context;
855
856					// We can use :scope instead of the ID hack if the browser
857					// supports it & if we're not changing the context.
858					if ( newContext !== context || !support.scope ) {
859
860						// Capture the context ID, setting it first if necessary
861						if ( ( nid = context.getAttribute( "id" ) ) ) {
862							nid = nid.replace( rcssescape, fcssescape );
863						} else {
864							context.setAttribute( "id", ( nid = expando ) );
865						}
866					}
867
868					// Prefix every selector in the list
869					groups = tokenize( selector );
870					i = groups.length;
871					while ( i-- ) {
872						groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
873							toSelector( groups[ i ] );
874					}
875					newSelector = groups.join( "," );
876				}
877
878				try {
879					push.apply( results,
880						newContext.querySelectorAll( newSelector )
881					);
882					return results;
883				} catch ( qsaError ) {
884					nonnativeSelectorCache( selector, true );
885				} finally {
886					if ( nid === expando ) {
887						context.removeAttribute( "id" );
888					}
889				}
890			}
891		}
892	}
893
894	// All others
895	return select( selector.replace( rtrim, "$1" ), context, results, seed );
896}
897
898/**
899 * Create key-value caches of limited size
900 * @returns {function(string, object)} Returns the Object data after storing it on itself with
901 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
902 *	deleting the oldest entry
903 */
904function createCache() {
905	var keys = [];
906
907	function cache( key, value ) {
908
909		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
910		if ( keys.push( key + " " ) > Expr.cacheLength ) {
911
912			// Only keep the most recent entries
913			delete cache[ keys.shift() ];
914		}
915		return ( cache[ key + " " ] = value );
916	}
917	return cache;
918}
919
920/**
921 * Mark a function for special use by Sizzle
922 * @param {Function} fn The function to mark
923 */
924function markFunction( fn ) {
925	fn[ expando ] = true;
926	return fn;
927}
928
929/**
930 * Support testing using an element
931 * @param {Function} fn Passed the created element and returns a boolean result
932 */
933function assert( fn ) {
934	var el = document.createElement( "fieldset" );
935
936	try {
937		return !!fn( el );
938	} catch ( e ) {
939		return false;
940	} finally {
941
942		// Remove from its parent by default
943		if ( el.parentNode ) {
944			el.parentNode.removeChild( el );
945		}
946
947		// release memory in IE
948		el = null;
949	}
950}
951
952/**
953 * Adds the same handler for all of the specified attrs
954 * @param {String} attrs Pipe-separated list of attributes
955 * @param {Function} handler The method that will be applied
956 */
957function addHandle( attrs, handler ) {
958	var arr = attrs.split( "|" ),
959		i = arr.length;
960
961	while ( i-- ) {
962		Expr.attrHandle[ arr[ i ] ] = handler;
963	}
964}
965
966/**
967 * Checks document order of two siblings
968 * @param {Element} a
969 * @param {Element} b
970 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
971 */
972function siblingCheck( a, b ) {
973	var cur = b && a,
974		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
975			a.sourceIndex - b.sourceIndex;
976
977	// Use IE sourceIndex if available on both nodes
978	if ( diff ) {
979		return diff;
980	}
981
982	// Check if b follows a
983	if ( cur ) {
984		while ( ( cur = cur.nextSibling ) ) {
985			if ( cur === b ) {
986				return -1;
987			}
988		}
989	}
990
991	return a ? 1 : -1;
992}
993
994/**
995 * Returns a function to use in pseudos for input types
996 * @param {String} type
997 */
998function createInputPseudo( type ) {
999	return function( elem ) {
1000		var name = elem.nodeName.toLowerCase();
1001		return name === "input" && elem.type === type;
1002	};
1003}
1004
1005/**
1006 * Returns a function to use in pseudos for buttons
1007 * @param {String} type
1008 */
1009function createButtonPseudo( type ) {
1010	return function( elem ) {
1011		var name = elem.nodeName.toLowerCase();
1012		return ( name === "input" || name === "button" ) && elem.type === type;
1013	};
1014}
1015
1016/**
1017 * Returns a function to use in pseudos for :enabled/:disabled
1018 * @param {Boolean} disabled true for :disabled; false for :enabled
1019 */
1020function createDisabledPseudo( disabled ) {
1021
1022	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1023	return function( elem ) {
1024
1025		// Only certain elements can match :enabled or :disabled
1026		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1027		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1028		if ( "form" in elem ) {
1029
1030			// Check for inherited disabledness on relevant non-disabled elements:
1031			// * listed form-associated elements in a disabled fieldset
1032			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
1033			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1034			// * option elements in a disabled optgroup
1035			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1036			// All such elements have a "form" property.
1037			if ( elem.parentNode && elem.disabled === false ) {
1038
1039				// Option elements defer to a parent optgroup if present
1040				if ( "label" in elem ) {
1041					if ( "label" in elem.parentNode ) {
1042						return elem.parentNode.disabled === disabled;
1043					} else {
1044						return elem.disabled === disabled;
1045					}
1046				}
1047
1048				// Support: IE 6 - 11
1049				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
1050				return elem.isDisabled === disabled ||
1051
1052					// Where there is no isDisabled, check manually
1053					/* jshint -W018 */
1054					elem.isDisabled !== !disabled &&
1055					inDisabledFieldset( elem ) === disabled;
1056			}
1057
1058			return elem.disabled === disabled;
1059
1060		// Try to winnow out elements that can't be disabled before trusting the disabled property.
1061		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1062		// even exist on them, let alone have a boolean value.
1063		} else if ( "label" in elem ) {
1064			return elem.disabled === disabled;
1065		}
1066
1067		// Remaining elements are neither :enabled nor :disabled
1068		return false;
1069	};
1070}
1071
1072/**
1073 * Returns a function to use in pseudos for positionals
1074 * @param {Function} fn
1075 */
1076function createPositionalPseudo( fn ) {
1077	return markFunction( function( argument ) {
1078		argument = +argument;
1079		return markFunction( function( seed, matches ) {
1080			var j,
1081				matchIndexes = fn( [], seed.length, argument ),
1082				i = matchIndexes.length;
1083
1084			// Match elements found at the specified indexes
1085			while ( i-- ) {
1086				if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
1087					seed[ j ] = !( matches[ j ] = seed[ j ] );
1088				}
1089			}
1090		} );
1091	} );
1092}
1093
1094/**
1095 * Checks a node for validity as a Sizzle context
1096 * @param {Element|Object=} context
1097 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1098 */
1099function testContext( context ) {
1100	return context && typeof context.getElementsByTagName !== "undefined" && context;
1101}
1102
1103// Expose support vars for convenience
1104support = Sizzle.support = {};
1105
1106/**
1107 * Detects XML nodes
1108 * @param {Element|Object} elem An element or a document
1109 * @returns {Boolean} True iff elem is a non-HTML XML node
1110 */
1111isXML = Sizzle.isXML = function( elem ) {
1112	var namespace = elem

1113 ( elem.ownerDocument || elem ).documentElement;
1114
1115	// Support: IE <=8
1116	// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
1117	// https://bugs.jquery.com/ticket/4833
1118	return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
1119};
1120
1121/**
1122 * Sets document-related variables once based on the current document
1123 * @param {Element|Object} [doc] An element or document object to use to set the document
1124 * @returns {Object} Returns the current document
1125 */
1126setDocument = Sizzle.setDocument = function( node ) {
1127	var hasCompare, subWindow,
1128		doc = node ? node.ownerDocument || node : preferredDoc;
1129
1130	// Return early if doc is invalid or already selected
1131	// Support: IE 11+, Edge 17 - 18+
1132	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1133	// two documents; shallow comparisons work.
1134	// eslint-disable-next-line eqeqeq
1135	if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
1136		return document;
1137	}
1138
1139	// Update global variables
1140	document = doc;
1141	docElem = document.documentElement;
1142	documentIsHTML = !isXML( document );
1143
1144	// Support: IE 9 - 11+, Edge 12 - 18+
1145	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1146	// Support: IE 11+, Edge 17 - 18+
1147	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1148	// two documents; shallow comparisons work.
1149	// eslint-disable-next-line eqeqeq
1150	if ( preferredDoc != document &&
1151		( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
1152
1153		// Support: IE 11, Edge
1154		if ( subWindow.addEventListener ) {
1155			subWindow.addEventListener( "unload", unloadHandler, false );
1156
1157		// Support: IE 9 - 10 only
1158		} else if ( subWindow.attachEvent ) {
1159			subWindow.attachEvent( "onunload", unloadHandler );
1160		}
1161	}
1162
1163	// Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,
1164	// Safari 4 - 5 only, Opera <=11.6 - 12.x only
1165	// IE/Edge & older browsers don't support the :scope pseudo-class.
1166	// Support: Safari 6.0 only
1167	// Safari 6.0 supports :scope but it's an alias of :root there.
1168	support.scope = assert( function( el ) {
1169		docElem.appendChild( el ).appendChild( document.createElement( "div" ) );
1170		return typeof el.querySelectorAll !== "undefined" &&
1171			!el.querySelectorAll( ":scope fieldset div" ).length;
1172	} );
1173
1174	/* Attributes
1175	---------------------------------------------------------------------- */
1176
1177	// Support: IE<8
1178	// Verify that getAttribute really returns attributes and not properties
1179	// (excepting IE8 booleans)
1180	support.attributes = assert( function( el ) {
1181		el.className = "i";
1182		return !el.getAttribute( "className" );
1183	} );
1184
1185	/* getElement(s)By*
1186	---------------------------------------------------------------------- */
1187
1188	// Check if getElementsByTagName("*") returns only elements
1189	support.getElementsByTagName = assert( function( el ) {
1190		el.appendChild( document.createComment( "" ) );
1191		return !el.getElementsByTagName( "*" ).length;
1192	} );
1193
1194	// Support: IE<9
1195	support.getElementsByClassName = rnative.test( document.getElementsByClassName );
1196
1197	// Support: IE<10
1198	// Check if getElementById returns elements by name
1199	// The broken getElementById methods don't pick up programmatically-set names,
1200	// so use a roundabout getElementsByName test
1201	support.getById = assert( function( el ) {
1202		docElem.appendChild( el ).id = expando;
1203		return !document.getElementsByName || !document.getElementsByName( expando ).length;
1204	} );
1205
1206	// ID filter and find
1207	if ( support.getById ) {
1208		Expr.filter[ "ID" ] = function( id ) {
1209			var attrId = id.replace( runescape, funescape );
1210			return function( elem ) {
1211				return elem.getAttribute( "id" ) === attrId;
1212			};
1213		};
1214		Expr.find[ "ID" ] = function( id, context ) {
1215			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1216				var elem = context.getElementById( id );
1217				return elem ? [ elem ] : [];
1218			}
1219		};
1220	} else {
1221		Expr.filter[ "ID" ] =  function( id ) {
1222			var attrId = id.replace( runescape, funescape );
1223			return function( elem ) {
1224				var node = typeof elem.getAttributeNode !== "undefined" &&
1225					elem.getAttributeNode( "id" );
1226				return node && node.value === attrId;
1227			};
1228		};
1229
1230		// Support: IE 6 - 7 only
1231		// getElementById is not reliable as a find shortcut
1232		Expr.find[ "ID" ] = function( id, context ) {
1233			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1234				var node, i, elems,
1235					elem = context.getElementById( id );
1236
1237				if ( elem ) {
1238
1239					// Verify the id attribute
1240					node = elem.getAttributeNode( "id" );
1241					if ( node && node.value === id ) {
1242						return [ elem ];
1243					}
1244
1245					// Fall back on getElementsByName
1246					elems = context.getElementsByName( id );
1247					i = 0;
1248					while ( ( elem = elems[ i++ ] ) ) {
1249						node = elem.getAttributeNode( "id" );
1250						if ( node && node.value === id ) {
1251							return [ elem ];
1252						}
1253					}
1254				}
1255
1256				return [];
1257			}
1258		};
1259	}
1260
1261	// Tag
1262	Expr.find[ "TAG" ] = support.getElementsByTagName ?
1263		function( tag, context ) {
1264			if ( typeof context.getElementsByTagName !== "undefined" ) {
1265				return context.getElementsByTagName( tag );
1266
1267			// DocumentFragment nodes don't have gEBTN
1268			} else if ( support.qsa ) {
1269				return context.querySelectorAll( tag );
1270			}
1271		} :
1272
1273		function( tag, context ) {
1274			var elem,
1275				tmp = [],
1276				i = 0,
1277
1278				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1279				results = context.getElementsByTagName( tag );
1280
1281			// Filter out possible comments
1282			if ( tag === "*" ) {
1283				while ( ( elem = results[ i++ ] ) ) {
1284					if ( elem.nodeType === 1 ) {
1285						tmp.push( elem );
1286					}
1287				}
1288
1289				return tmp;
1290			}
1291			return results;
1292		};
1293
1294	// Class
1295	Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) {
1296		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1297			return context.getElementsByClassName( className );
1298		}
1299	};
1300
1301	/* QSA/matchesSelector
1302	---------------------------------------------------------------------- */
1303
1304	// QSA and matchesSelector support
1305
1306	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1307	rbuggyMatches = [];
1308
1309	// qSa(:focus) reports false when true (Chrome 21)
1310	// We allow this because of a bug in IE8/9 that throws an error
1311	// whenever `document.activeElement` is accessed on an iframe
1312	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1313	// See https://bugs.jquery.com/ticket/13378
1314	rbuggyQSA = [];
1315
1316	if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {
1317
1318		// Build QSA regex
1319		// Regex strategy adopted from Diego Perini
1320		assert( function( el ) {
1321
1322			var input;
1323
1324			// Select is set to empty string on purpose
1325			// This is to test IE's treatment of not explicitly
1326			// setting a boolean content attribute,
1327			// since its presence should be enough
1328			// https://bugs.jquery.com/ticket/12359
1329			docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
1330				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
1331				"<option selected=''></option></select>";
1332
1333			// Support: IE8, Opera 11-12.16
1334			// Nothing should be selected when empty strings follow ^= or $= or *=
1335			// The test attribute must be unknown in Opera but "safe" for WinRT
1336			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1337			if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) {
1338				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1339			}
1340
1341			// Support: IE8
1342			// Boolean attributes and "value" are not treated correctly
1343			if ( !el.querySelectorAll( "[selected]" ).length ) {
1344				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1345			}
1346
1347			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1348			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1349				rbuggyQSA.push( "~=" );
1350			}
1351
1352			// Support: IE 11+, Edge 15 - 18+
1353			// IE 11/Edge don't find elements on a `[name='']` query in some cases.
1354			// Adding a temporary attribute to the document before the selection works
1355			// around the issue.
1356			// Interestingly, IE 10 & older don't seem to have the issue.
1357			input = document.createElement( "input" );
1358			input.setAttribute( "name", "" );
1359			el.appendChild( input );
1360			if ( !el.querySelectorAll( "[name='']" ).length ) {
1361				rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
1362					whitespace + "*(?:''|\"\")" );
1363			}
1364
1365			// Webkit/Opera - :checked should return selected option elements
1366			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1367			// IE8 throws error here and will not see later tests
1368			if ( !el.querySelectorAll( ":checked" ).length ) {
1369				rbuggyQSA.push( ":checked" );
1370			}
1371
1372			// Support: Safari 8+, iOS 8+
1373			// https://bugs.webkit.org/show_bug.cgi?id=136851
1374			// In-page `selector#id sibling-combinator selector` fails
1375			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
1376				rbuggyQSA.push( ".#.+[+~]" );
1377			}
1378
1379			// Support: Firefox <=3.6 - 5 only
1380			// Old Firefox doesn't throw on a badly-escaped identifier.
1381			el.querySelectorAll( "\\\f" );
1382			rbuggyQSA.push( "[\\r\\n\\f]" );
1383		} );
1384
1385		assert( function( el ) {
1386			el.innerHTML = "<a href='' disabled='disabled'></a>" +
1387				"<select disabled='disabled'><option/></select>";
1388
1389			// Support: Windows 8 Native Apps
1390			// The type and name attributes are restricted during .innerHTML assignment
1391			var input = document.createElement( "input" );
1392			input.setAttribute( "type", "hidden" );
1393			el.appendChild( input ).setAttribute( "name", "D" );
1394
1395			// Support: IE8
1396			// Enforce case-sensitivity of name attribute
1397			if ( el.querySelectorAll( "[name=d]" ).length ) {
1398				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1399			}
1400
1401			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1402			// IE8 throws error here and will not see later tests
1403			if ( el.querySelectorAll( ":enabled" ).length !== 2 ) {
1404				rbuggyQSA.push( ":enabled", ":disabled" );
1405			}
1406
1407			// Support: IE9-11+
1408			// IE's :disabled selector does not pick up the children of disabled fieldsets
1409			docElem.appendChild( el ).disabled = true;
1410			if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
1411				rbuggyQSA.push( ":enabled", ":disabled" );
1412			}
1413
1414			// Support: Opera 10 - 11 only
1415			// Opera 10-11 does not throw on post-comma invalid pseudos
1416			el.querySelectorAll( "*,:x" );
1417			rbuggyQSA.push( ",.*:" );
1418		} );
1419	}
1420
1421	if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||
1422		docElem.webkitMatchesSelector ||
1423		docElem.mozMatchesSelector ||
1424		docElem.oMatchesSelector ||
1425		docElem.msMatchesSelector ) ) ) ) {
1426
1427		assert( function( el ) {
1428
1429			// Check to see if it's possible to do matchesSelector
1430			// on a disconnected node (IE 9)
1431			support.disconnectedMatch = matches.call( el, "*" );
1432
1433			// This should fail with an exception
1434			// Gecko does not error, returns false instead
1435			matches.call( el, "[s!='']:x" );
1436			rbuggyMatches.push( "!=", pseudos );
1437		} );
1438	}
1439
1440	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
1441	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) );
1442
1443	/* Contains
1444	---------------------------------------------------------------------- */
1445	hasCompare = rnative.test( docElem.compareDocumentPosition );
1446
1447	// Element contains another
1448	// Purposefully self-exclusive
1449	// As in, an element does not contain itself
1450	contains = hasCompare || rnative.test( docElem.contains ) ?
1451		function( a, b ) {
1452			var adown = a.nodeType === 9 ? a.documentElement : a,
1453				bup = b && b.parentNode;
1454			return a === bup || !!( bup && bup.nodeType === 1 && (
1455				adown.contains ?
1456					adown.contains( bup ) :
1457					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1458			) );
1459		} :
1460		function( a, b ) {
1461			if ( b ) {
1462				while ( ( b = b.parentNode ) ) {
1463					if ( b === a ) {
1464						return true;
1465					}
1466				}
1467			}
1468			return false;
1469		};
1470
1471	/* Sorting
1472	---------------------------------------------------------------------- */
1473
1474	// Document order sorting
1475	sortOrder = hasCompare ?
1476	function( a, b ) {
1477
1478		// Flag for duplicate removal
1479		if ( a === b ) {
1480			hasDuplicate = true;
1481			return 0;
1482		}
1483
1484		// Sort on method existence if only one input has compareDocumentPosition
1485		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1486		if ( compare ) {
1487			return compare;
1488		}
1489
1490		// Calculate position if both inputs belong to the same document
1491		// Support: IE 11+, Edge 17 - 18+
1492		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1493		// two documents; shallow comparisons work.
1494		// eslint-disable-next-line eqeqeq
1495		compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
1496			a.compareDocumentPosition( b ) :
1497
1498			// Otherwise we know they are disconnected
1499			1;
1500
1501		// Disconnected nodes
1502		if ( compare & 1 ||
1503			( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {
1504
1505			// Choose the first element that is related to our preferred document
1506			// Support: IE 11+, Edge 17 - 18+
1507			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1508			// two documents; shallow comparisons work.
1509			// eslint-disable-next-line eqeqeq
1510			if ( a == document || a.ownerDocument == preferredDoc &&
1511				contains( preferredDoc, a ) ) {
1512				return -1;
1513			}
1514
1515			// Support: IE 11+, Edge 17 - 18+
1516			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1517			// two documents; shallow comparisons work.
1518			// eslint-disable-next-line eqeqeq
1519			if ( b == document || b.ownerDocument == preferredDoc &&
1520				contains( preferredDoc, b ) ) {
1521				return 1;
1522			}
1523
1524			// Maintain original order
1525			return sortInput ?
1526				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1527				0;
1528		}
1529
1530		return compare & 4 ? -1 : 1;
1531	} :
1532	function( a, b ) {
1533
1534		// Exit early if the nodes are identical
1535		if ( a === b ) {
1536			hasDuplicate = true;
1537			return 0;
1538		}
1539
1540		var cur,
1541			i = 0,
1542			aup = a.parentNode,
1543			bup = b.parentNode,
1544			ap = [ a ],
1545			bp = [ b ];
1546
1547		// Parentless nodes are either documents or disconnected
1548		if ( !aup || !bup ) {
1549
1550			// Support: IE 11+, Edge 17 - 18+
1551			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1552			// two documents; shallow comparisons work.
1553			/* eslint-disable eqeqeq */
1554			return a == document ? -1 :
1555				b == document ? 1 :
1556				/* eslint-enable eqeqeq */
1557				aup ? -1 :
1558				bup ? 1 :
1559				sortInput ?
1560				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1561				0;
1562
1563		// If the nodes are siblings, we can do a quick check
1564		} else if ( aup === bup ) {
1565			return siblingCheck( a, b );
1566		}
1567
1568		// Otherwise we need full lists of their ancestors for comparison
1569		cur = a;
1570		while ( ( cur = cur.parentNode ) ) {
1571			ap.unshift( cur );
1572		}
1573		cur = b;
1574		while ( ( cur = cur.parentNode ) ) {
1575			bp.unshift( cur );
1576		}
1577
1578		// Walk down the tree looking for a discrepancy
1579		while ( ap[ i ] === bp[ i ] ) {
1580			i++;
1581		}
1582
1583		return i ?
1584
1585			// Do a sibling check if the nodes have a common ancestor
1586			siblingCheck( ap[ i ], bp[ i ] ) :
1587
1588			// Otherwise nodes in our document sort first
1589			// Support: IE 11+, Edge 17 - 18+
1590			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1591			// two documents; shallow comparisons work.
1592			/* eslint-disable eqeqeq */
1593			ap[ i ] == preferredDoc ? -1 :
1594			bp[ i ] == preferredDoc ? 1 :
1595			/* eslint-enable eqeqeq */
1596			0;
1597	};
1598
1599	return document;
1600};
1601
1602Sizzle.matches = function( expr, elements ) {
1603	return Sizzle( expr, null, null, elements );
1604};
1605
1606Sizzle.matchesSelector = function( elem, expr ) {
1607	setDocument( elem );
1608
1609	if ( support.matchesSelector && documentIsHTML &&
1610		!nonnativeSelectorCache[ expr + " " ] &&
1611		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1612		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1613
1614		try {
1615			var ret = matches.call( elem, expr );
1616
1617			// IE 9's matchesSelector returns false on disconnected nodes
1618			if ( ret || support.disconnectedMatch ||
1619
1620				// As well, disconnected nodes are said to be in a document
1621				// fragment in IE 9
1622				elem.document && elem.document.nodeType !== 11 ) {
1623				return ret;
1624			}
1625		} catch ( e ) {
1626			nonnativeSelectorCache( expr, true );
1627		}
1628	}
1629
1630	return Sizzle( expr, document, null, [ elem ] ).length > 0;
1631};
1632
1633Sizzle.contains = function( context, elem ) {
1634
1635	// Set document vars if needed
1636	// Support: IE 11+, Edge 17 - 18+
1637	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1638	// two documents; shallow comparisons work.
1639	// eslint-disable-next-line eqeqeq
1640	if ( ( context.ownerDocument || context ) != document ) {
1641		setDocument( context );
1642	}
1643	return contains( context, elem );
1644};
1645
1646Sizzle.attr = function( elem, name ) {
1647
1648	// Set document vars if needed
1649	// Support: IE 11+, Edge 17 - 18+
1650	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1651	// two documents; shallow comparisons work.
1652	// eslint-disable-next-line eqeqeq
1653	if ( ( elem.ownerDocument || elem ) != document ) {
1654		setDocument( elem );
1655	}
1656
1657	var fn = Expr.attrHandle[ name.toLowerCase() ],
1658
1659		// Don't get fooled by Object.prototype properties (jQuery #13807)
1660		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1661			fn( elem, name, !documentIsHTML ) :
1662			undefined;
1663
1664	return val !== undefined ?
1665		val :
1666		support.attributes || !documentIsHTML ?
1667			elem.getAttribute( name ) :
1668			( val = elem.getAttributeNode( name ) ) && val.specified ?
1669				val.value :
1670				null;
1671};
1672
1673Sizzle.escape = function( sel ) {
1674	return ( sel + "" ).replace( rcssescape, fcssescape );
1675};
1676
1677Sizzle.error = function( msg ) {
1678	throw new Error( "Syntax error, unrecognized expression: " + msg );
1679};
1680
1681/**
1682 * Document sorting and removing duplicates
1683 * @param {ArrayLike} results
1684 */
1685Sizzle.uniqueSort = function( results ) {
1686	var elem,
1687		duplicates = [],
1688		j = 0,
1689		i = 0;
1690
1691	// Unless we *know* we can detect duplicates, assume their presence
1692	hasDuplicate = !support.detectDuplicates;
1693	sortInput = !support.sortStable && results.slice( 0 );
1694	results.sort( sortOrder );
1695
1696	if ( hasDuplicate ) {
1697		while ( ( elem = results[ i++ ] ) ) {
1698			if ( elem === results[ i ] ) {
1699				j = duplicates.push( i );
1700			}
1701		}
1702		while ( j-- ) {
1703			results.splice( duplicates[ j ], 1 );
1704		}
1705	}
1706
1707	// Clear input after sorting to release objects
1708	// See https://github.com/jquery/sizzle/pull/225
1709	sortInput = null;
1710
1711	return results;
1712};
1713
1714/**
1715 * Utility function for retrieving the text value of an array of DOM nodes
1716 * @param {Array|Element} elem
1717 */
1718getText = Sizzle.getText = function( elem ) {
1719	var node,
1720		ret = "",
1721		i = 0,
1722		nodeType = elem.nodeType;
1723
1724	if ( !nodeType ) {
1725
1726		// If no nodeType, this is expected to be an array
1727		while ( ( node = elem[ i++ ] ) ) {
1728
1729			// Do not traverse comment nodes
1730			ret += getText( node );
1731		}
1732	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1733
1734		// Use textContent for elements
1735		// innerText usage removed for consistency of new lines (jQuery #11153)
1736		if ( typeof elem.textContent === "string" ) {
1737			return elem.textContent;
1738		} else {
1739
1740			// Traverse its children
1741			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1742				ret += getText( elem );
1743			}
1744		}
1745	} else if ( nodeType === 3 || nodeType === 4 ) {
1746		return elem.nodeValue;
1747	}
1748
1749	// Do not include comment or processing instruction nodes
1750
1751	return ret;
1752};
1753
1754Expr = Sizzle.selectors = {
1755
1756	// Can be adjusted by the user
1757	cacheLength: 50,
1758
1759	createPseudo: markFunction,
1760
1761	match: matchExpr,
1762
1763	attrHandle: {},
1764
1765	find: {},
1766
1767	relative: {
1768		">": { dir: "parentNode", first: true },
1769		" ": { dir: "parentNode" },
1770		"+": { dir: "previousSibling", first: true },
1771		"~": { dir: "previousSibling" }
1772	},
1773
1774	preFilter: {
1775		"ATTR": function( match ) {
1776			match[ 1 ] = match[ 1 ].replace( runescape, funescape );
1777
1778			// Move the given value to match[3] whether quoted or unquoted
1779			match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||
1780				match[ 5 ] || "" ).replace( runescape, funescape );
1781
1782			if ( match[ 2 ] === "~=" ) {
1783				match[ 3 ] = " " + match[ 3 ] + " ";
1784			}
1785
1786			return match.slice( 0, 4 );
1787		},
1788
1789		"CHILD": function( match ) {
1790
1791			/* matches from matchExpr["CHILD"]
1792				1 type (only|nth|...)
1793				2 what (child|of-type)
1794				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1795				4 xn-component of xn+y argument ([+-]?\d*n|)
1796				5 sign of xn-component
1797				6 x of xn-component
1798				7 sign of y-component
1799				8 y of y-component
1800			*/
1801			match[ 1 ] = match[ 1 ].toLowerCase();
1802
1803			if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
1804
1805				// nth-* requires argument
1806				if ( !match[ 3 ] ) {
1807					Sizzle.error( match[ 0 ] );
1808				}
1809
1810				// numeric x and y parameters for Expr.filter.CHILD
1811				// remember that false/true cast respectively to 0/1
1812				match[ 4 ] = +( match[ 4 ] ?
1813					match[ 5 ] + ( match[ 6 ] || 1 ) :
1814					2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) );
1815				match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
1816
1817				// other types prohibit arguments
1818			} else if ( match[ 3 ] ) {
1819				Sizzle.error( match[ 0 ] );
1820			}
1821
1822			return match;
1823		},
1824
1825		"PSEUDO": function( match ) {
1826			var excess,
1827				unquoted = !match[ 6 ] && match[ 2 ];
1828
1829			if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) {
1830				return null;
1831			}
1832
1833			// Accept quoted arguments as-is
1834			if ( match[ 3 ] ) {
1835				match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
1836
1837			// Strip excess characters from unquoted arguments
1838			} else if ( unquoted && rpseudo.test( unquoted ) &&
1839
1840				// Get excess from tokenize (recursively)
1841				( excess = tokenize( unquoted, true ) ) &&
1842
1843				// advance to the next closing parenthesis
1844				( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
1845
1846				// excess is a negative index
1847				match[ 0 ] = match[ 0 ].slice( 0, excess );
1848				match[ 2 ] = unquoted.slice( 0, excess );
1849			}
1850
1851			// Return only captures needed by the pseudo filter method (type and argument)
1852			return match.slice( 0, 3 );
1853		}
1854	},
1855
1856	filter: {
1857
1858		"TAG": function( nodeNameSelector ) {
1859			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1860			return nodeNameSelector === "*" ?
1861				function() {
1862					return true;
1863				} :
1864				function( elem ) {
1865					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1866				};
1867		},
1868
1869		"CLASS": function( className ) {
1870			var pattern = classCache[ className + " " ];
1871
1872			return pattern ||
1873				( pattern = new RegExp( "(^|" + whitespace +
1874					")" + className + "(" + whitespace + "|$)" ) ) && classCache(
1875						className, function( elem ) {
1876							return pattern.test(
1877								typeof elem.className === "string" && elem.className ||
1878								typeof elem.getAttribute !== "undefined" &&
1879									elem.getAttribute( "class" ) ||
1880								""
1881							);
1882				} );
1883		},
1884
1885		"ATTR": function( name, operator, check ) {
1886			return function( elem ) {
1887				var result = Sizzle.attr( elem, name );
1888
1889				if ( result == null ) {
1890					return operator === "!=";
1891				}
1892				if ( !operator ) {
1893					return true;
1894				}
1895
1896				result += "";
1897
1898				/* eslint-disable max-len */
1899
1900				return operator === "=" ? result === check :
1901					operator === "!=" ? result !== check :
1902					operator === "^=" ? check && result.indexOf( check ) === 0 :
1903					operator === "*=" ? check && result.indexOf( check ) > -1 :
1904					operator === "$=" ? check && result.slice( -check.length ) === check :
1905					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1906					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1907					false;
1908				/* eslint-enable max-len */
1909
1910			};
1911		},
1912
1913		"CHILD": function( type, what, _argument, first, last ) {
1914			var simple = type.slice( 0, 3 ) !== "nth",
1915				forward = type.slice( -4 ) !== "last",
1916				ofType = what === "of-type";
1917
1918			return first === 1 && last === 0 ?
1919
1920				// Shortcut for :nth-*(n)
1921				function( elem ) {
1922					return !!elem.parentNode;
1923				} :
1924
1925				function( elem, _context, xml ) {
1926					var cache, uniqueCache, outerCache, node, nodeIndex, start,
1927						dir = simple !== forward ? "nextSibling" : "previousSibling",
1928						parent = elem.parentNode,
1929						name = ofType && elem.nodeName.toLowerCase(),
1930						useCache = !xml && !ofType,
1931						diff = false;
1932
1933					if ( parent ) {
1934
1935						// :(first|last|only)-(child|of-type)
1936						if ( simple ) {
1937							while ( dir ) {
1938								node = elem;
1939								while ( ( node = node[ dir ] ) ) {
1940									if ( ofType ?
1941										node.nodeName.toLowerCase() === name :
1942										node.nodeType === 1 ) {
1943
1944										return false;
1945									}
1946								}
1947
1948								// Reverse direction for :only-* (if we haven't yet done so)
1949								start = dir = type === "only" && !start && "nextSibling";
1950							}
1951							return true;
1952						}
1953
1954						start = [ forward ? parent.firstChild : parent.lastChild ];
1955
1956						// non-xml :nth-child(...) stores cache data on `parent`
1957						if ( forward && useCache ) {
1958
1959							// Seek `elem` from a previously-cached index
1960
1961							// ...in a gzip-friendly way
1962							node = parent;
1963							outerCache = node[ expando ] || ( node[ expando ] = {} );
1964
1965							// Support: IE <9 only
1966							// Defend against cloned attroperties (jQuery gh-1709)
1967							uniqueCache = outerCache[ node.uniqueID ] ||
1968								( outerCache[ node.uniqueID ] = {} );
1969
1970							cache = uniqueCache[ type ] || [];
1971							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1972							diff = nodeIndex && cache[ 2 ];
1973							node = nodeIndex && parent.childNodes[ nodeIndex ];
1974
1975							while ( ( node = ++nodeIndex && node && node[ dir ] ||
1976
1977								// Fallback to seeking `elem` from the start
1978								( diff = nodeIndex = 0 ) || start.pop() ) ) {
1979
1980								// When found, cache indexes on `parent` and break
1981								if ( node.nodeType === 1 && ++diff && node === elem ) {
1982									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1983									break;
1984								}
1985							}
1986
1987						} else {
1988
1989							// Use previously-cached element index if available
1990							if ( useCache ) {
1991
1992								// ...in a gzip-friendly way
1993								node = elem;
1994								outerCache = node[ expando ] || ( node[ expando ] = {} );
1995
1996								// Support: IE <9 only
1997								// Defend against cloned attroperties (jQuery gh-1709)
1998								uniqueCache = outerCache[ node.uniqueID ] ||
1999									( outerCache[ node.uniqueID ] = {} );
2000
2001								cache = uniqueCache[ type ] || [];
2002								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
2003								diff = nodeIndex;
2004							}
2005
2006							// xml :nth-child(...)
2007							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
2008							if ( diff === false ) {
2009
2010								// Use the same loop as above to seek `elem` from the start
2011								while ( ( node = ++nodeIndex && node && node[ dir ] ||
2012									( diff = nodeIndex = 0 ) || start.pop() ) ) {
2013
2014									if ( ( ofType ?
2015										node.nodeName.toLowerCase() === name :
2016										node.nodeType === 1 ) &&
2017										++diff ) {
2018
2019										// Cache the index of each encountered element
2020										if ( useCache ) {
2021											outerCache = node[ expando ] ||
2022												( node[ expando ] = {} );
2023
2024											// Support: IE <9 only
2025											// Defend against cloned attroperties (jQuery gh-1709)
2026											uniqueCache = outerCache[ node.uniqueID ] ||
2027												( outerCache[ node.uniqueID ] = {} );
2028
2029											uniqueCache[ type ] = [ dirruns, diff ];
2030										}
2031
2032										if ( node === elem ) {
2033											break;
2034										}
2035									}
2036								}
2037							}
2038						}
2039
2040						// Incorporate the offset, then check against cycle size
2041						diff -= last;
2042						return diff === first || ( diff % first === 0 && diff / first >= 0 );
2043					}
2044				};
2045		},
2046
2047		"PSEUDO": function( pseudo, argument ) {
2048
2049			// pseudo-class names are case-insensitive
2050			// http://www.w3.org/TR/selectors/#pseudo-classes
2051			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2052			// Remember that setFilters inherits from pseudos
2053			var args,
2054				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2055					Sizzle.error( "unsupported pseudo: " + pseudo );
2056
2057			// The user may use createPseudo to indicate that
2058			// arguments are needed to create the filter function
2059			// just as Sizzle does
2060			if ( fn[ expando ] ) {
2061				return fn( argument );
2062			}
2063
2064			// But maintain support for old signatures
2065			if ( fn.length > 1 ) {
2066				args = [ pseudo, pseudo, "", argument ];
2067				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2068					markFunction( function( seed, matches ) {
2069						var idx,
2070							matched = fn( seed, argument ),
2071							i = matched.length;
2072						while ( i-- ) {
2073							idx = indexOf( seed, matched[ i ] );
2074							seed[ idx ] = !( matches[ idx ] = matched[ i ] );
2075						}
2076					} ) :
2077					function( elem ) {
2078						return fn( elem, 0, args );
2079					};
2080			}
2081
2082			return fn;
2083		}
2084	},
2085
2086	pseudos: {
2087
2088		// Potentially complex pseudos
2089		"not": markFunction( function( selector ) {
2090
2091			// Trim the selector passed to compile
2092			// to avoid treating leading and trailing
2093			// spaces as combinators
2094			var input = [],
2095				results = [],
2096				matcher = compile( selector.replace( rtrim, "$1" ) );
2097
2098			return matcher[ expando ] ?
2099				markFunction( function( seed, matches, _context, xml ) {
2100					var elem,
2101						unmatched = matcher( seed, null, xml, [] ),
2102						i = seed.length;
2103
2104					// Match elements unmatched by `matcher`
2105					while ( i-- ) {
2106						if ( ( elem = unmatched[ i ] ) ) {
2107							seed[ i ] = !( matches[ i ] = elem );
2108						}
2109					}
2110				} ) :
2111				function( elem, _context, xml ) {
2112					input[ 0 ] = elem;
2113					matcher( input, null, xml, results );
2114
2115					// Don't keep the element (issue #299)
2116					input[ 0 ] = null;
2117					return !results.pop();
2118				};
2119		} ),
2120
2121		"has": markFunction( function( selector ) {
2122			return function( elem ) {
2123				return Sizzle( selector, elem ).length > 0;
2124			};
2125		} ),
2126
2127		"contains": markFunction( function( text ) {
2128			text = text.replace( runescape, funescape );
2129			return function( elem ) {
2130				return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
2131			};
2132		} ),
2133
2134		// "Whether an element is represented by a :lang() selector
2135		// is based solely on the element's language value
2136		// being equal to the identifier C,
2137		// or beginning with the identifier C immediately followed by "-".
2138		// The matching of C against the element's language value is performed case-insensitively.
2139		// The identifier C does not have to be a valid language name."
2140		// http://www.w3.org/TR/selectors/#lang-pseudo
2141		"lang": markFunction( function( lang ) {
2142
2143			// lang value must be a valid identifier
2144			if ( !ridentifier.test( lang || "" ) ) {
2145				Sizzle.error( "unsupported lang: " + lang );
2146			}
2147			lang = lang.replace( runescape, funescape ).toLowerCase();
2148			return function( elem ) {
2149				var elemLang;
2150				do {
2151					if ( ( elemLang = documentIsHTML ?
2152						elem.lang :
2153						elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
2154
2155						elemLang = elemLang.toLowerCase();
2156						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2157					}
2158				} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
2159				return false;
2160			};
2161		} ),
2162
2163		// Miscellaneous
2164		"target": function( elem ) {
2165			var hash = window.location && window.location.hash;
2166			return hash && hash.slice( 1 ) === elem.id;
2167		},
2168
2169		"root": function( elem ) {
2170			return elem === docElem;
2171		},
2172
2173		"focus": function( elem ) {
2174			return elem === document.activeElement &&
2175				( !document.hasFocus || document.hasFocus() ) &&
2176				!!( elem.type || elem.href || ~elem.tabIndex );
2177		},
2178
2179		// Boolean properties
2180		"enabled": createDisabledPseudo( false ),
2181		"disabled": createDisabledPseudo( true ),
2182
2183		"checked": function( elem ) {
2184
2185			// In CSS3, :checked should return both checked and selected elements
2186			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2187			var nodeName = elem.nodeName.toLowerCase();
2188			return ( nodeName === "input" && !!elem.checked ) ||
2189				( nodeName === "option" && !!elem.selected );
2190		},
2191
2192		"selected": function( elem ) {
2193
2194			// Accessing this property makes selected-by-default
2195			// options in Safari work properly
2196			if ( elem.parentNode ) {
2197				// eslint-disable-next-line no-unused-expressions
2198				elem.parentNode.selectedIndex;
2199			}
2200
2201			return elem.selected === true;
2202		},
2203
2204		// Contents
2205		"empty": function( elem ) {
2206
2207			// http://www.w3.org/TR/selectors/#empty-pseudo
2208			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2209			//   but not by others (comment: 8; processing instruction: 7; etc.)
2210			// nodeType < 6 works because attributes (2) do not appear as children
2211			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2212				if ( elem.nodeType < 6 ) {
2213					return false;
2214				}
2215			}
2216			return true;
2217		},
2218
2219		"parent": function( elem ) {
2220			return !Expr.pseudos[ "empty" ]( elem );
2221		},
2222
2223		// Element/input types
2224		"header": function( elem ) {
2225			return rheader.test( elem.nodeName );
2226		},
2227
2228		"input": function( elem ) {
2229			return rinputs.test( elem.nodeName );
2230		},
2231
2232		"button": function( elem ) {
2233			var name = elem.nodeName.toLowerCase();
2234			return name === "input" && elem.type === "button" || name === "button";
2235		},
2236
2237		"text": function( elem ) {
2238			var attr;
2239			return elem.nodeName.toLowerCase() === "input" &&
2240				elem.type === "text" &&
2241
2242				// Support: IE<8
2243				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2244				( ( attr = elem.getAttribute( "type" ) ) == null ||
2245					attr.toLowerCase() === "text" );
2246		},
2247
2248		// Position-in-collection
2249		"first": createPositionalPseudo( function() {
2250			return [ 0 ];
2251		} ),
2252
2253		"last": createPositionalPseudo( function( _matchIndexes, length ) {
2254			return [ length - 1 ];
2255		} ),
2256
2257		"eq": createPositionalPseudo( function( _matchIndexes, length, argument ) {
2258			return [ argument < 0 ? argument + length : argument ];
2259		} ),
2260
2261		"even": createPositionalPseudo( function( matchIndexes, length ) {
2262			var i = 0;
2263			for ( ; i < length; i += 2 ) {
2264				matchIndexes.push( i );
2265			}
2266			return matchIndexes;
2267		} ),
2268
2269		"odd": createPositionalPseudo( function( matchIndexes, length ) {
2270			var i = 1;
2271			for ( ; i < length; i += 2 ) {
2272				matchIndexes.push( i );
2273			}
2274			return matchIndexes;
2275		} ),
2276
2277		"lt": createPositionalPseudo( function( matchIndexes, length, argument ) {
2278			var i = argument < 0 ?
2279				argument + length :
2280				argument > length ?
2281					length :
2282					argument;
2283			for ( ; --i >= 0; ) {
2284				matchIndexes.push( i );
2285			}
2286			return matchIndexes;
2287		} ),
2288
2289		"gt": createPositionalPseudo( function( matchIndexes, length, argument ) {
2290			var i = argument < 0 ? argument + length : argument;
2291			for ( ; ++i < length; ) {
2292				matchIndexes.push( i );
2293			}
2294			return matchIndexes;
2295		} )
2296	}
2297};
2298
2299Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ];
2300
2301// Add button/input type pseudos
2302for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2303	Expr.pseudos[ i ] = createInputPseudo( i );
2304}
2305for ( i in { submit: true, reset: true } ) {
2306	Expr.pseudos[ i ] = createButtonPseudo( i );
2307}
2308
2309// Easy API for creating new setFilters
2310function setFilters() {}
2311setFilters.prototype = Expr.filters = Expr.pseudos;
2312Expr.setFilters = new setFilters();
2313
2314tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2315	var matched, match, tokens, type,
2316		soFar, groups, preFilters,
2317		cached = tokenCache[ selector + " " ];
2318
2319	if ( cached ) {
2320		return parseOnly ? 0 : cached.slice( 0 );
2321	}
2322
2323	soFar = selector;
2324	groups = [];
2325	preFilters = Expr.preFilter;
2326
2327	while ( soFar ) {
2328
2329		// Comma and first run
2330		if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
2331			if ( match ) {
2332
2333				// Don't consume trailing commas as valid
2334				soFar = soFar.slice( match[ 0 ].length ) || soFar;
2335			}
2336			groups.push( ( tokens = [] ) );
2337		}
2338
2339		matched = false;
2340
2341		// Combinators
2342		if ( ( match = rcombinators.exec( soFar ) ) ) {
2343			matched = match.shift();
2344			tokens.push( {
2345				value: matched,
2346
2347				// Cast descendant combinators to space
2348				type: match[ 0 ].replace( rtrim, " " )
2349			} );
2350			soFar = soFar.slice( matched.length );
2351		}
2352
2353		// Filters
2354		for ( type in Expr.filter ) {
2355			if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
2356				( match = preFilters[ type ]( match ) ) ) ) {
2357				matched = match.shift();
2358				tokens.push( {
2359					value: matched,
2360					type: type,
2361					matches: match
2362				} );
2363				soFar = soFar.slice( matched.length );
2364			}
2365		}
2366
2367		if ( !matched ) {
2368			break;
2369		}
2370	}
2371
2372	// Return the length of the invalid excess
2373	// if we're just parsing
2374	// Otherwise, throw an error or return tokens
2375	return parseOnly ?
2376		soFar.length :
2377		soFar ?
2378			Sizzle.error( selector ) :
2379
2380			// Cache the tokens
2381			tokenCache( selector, groups ).slice( 0 );
2382};
2383
2384function toSelector( tokens ) {
2385	var i = 0,
2386		len = tokens.length,
2387		selector = "";
2388	for ( ; i < len; i++ ) {
2389		selector += tokens[ i ].value;
2390	}
2391	return selector;
2392}
2393
2394function addCombinator( matcher, combinator, base ) {
2395	var dir = combinator.dir,
2396		skip = combinator.next,
2397		key = skip || dir,
2398		checkNonElements = base && key === "parentNode",
2399		doneName = done++;
2400
2401	return combinator.first ?
2402
2403		// Check against closest ancestor/preceding element
2404		function( elem, context, xml ) {
2405			while ( ( elem = elem[ dir ] ) ) {
2406				if ( elem.nodeType === 1 || checkNonElements ) {
2407					return matcher( elem, context, xml );
2408				}
2409			}
2410			return false;
2411		} :
2412
2413		// Check against all ancestor/preceding elements
2414		function( elem, context, xml ) {
2415			var oldCache, uniqueCache, outerCache,
2416				newCache = [ dirruns, doneName ];
2417
2418			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2419			if ( xml ) {
2420				while ( ( elem = elem[ dir ] ) ) {
2421					if ( elem.nodeType === 1 || checkNonElements ) {
2422						if ( matcher( elem, context, xml ) ) {
2423							return true;
2424						}
2425					}
2426				}
2427			} else {
2428				while ( ( elem = elem[ dir ] ) ) {
2429					if ( elem.nodeType === 1 || checkNonElements ) {
2430						outerCache = elem[ expando ] || ( elem[ expando ] = {} );
2431
2432						// Support: IE <9 only
2433						// Defend against cloned attroperties (jQuery gh-1709)
2434						uniqueCache = outerCache[ elem.uniqueID ] ||
2435							( outerCache[ elem.uniqueID ] = {} );
2436
2437						if ( skip && skip === elem.nodeName.toLowerCase() ) {
2438							elem = elem[ dir ] || elem;
2439						} else if ( ( oldCache = uniqueCache[ key ] ) &&
2440							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2441
2442							// Assign to newCache so results back-propagate to previous elements
2443							return ( newCache[ 2 ] = oldCache[ 2 ] );
2444						} else {
2445
2446							// Reuse newcache so results back-propagate to previous elements
2447							uniqueCache[ key ] = newCache;
2448
2449							// A match means we're done; a fail means we have to keep checking
2450							if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
2451								return true;
2452							}
2453						}
2454					}
2455				}
2456			}
2457			return false;
2458		};
2459}
2460
2461function elementMatcher( matchers ) {
2462	return matchers.length > 1 ?
2463		function( elem, context, xml ) {
2464			var i = matchers.length;
2465			while ( i-- ) {
2466				if ( !matchers[ i ]( elem, context, xml ) ) {
2467					return false;
2468				}
2469			}
2470			return true;
2471		} :
2472		matchers[ 0 ];
2473}
2474
2475function multipleContexts( selector, contexts, results ) {
2476	var i = 0,
2477		len = contexts.length;
2478	for ( ; i < len; i++ ) {
2479		Sizzle( selector, contexts[ i ], results );
2480	}
2481	return results;
2482}
2483
2484function condense( unmatched, map, filter, context, xml ) {
2485	var elem,
2486		newUnmatched = [],
2487		i = 0,
2488		len = unmatched.length,
2489		mapped = map != null;
2490
2491	for ( ; i < len; i++ ) {
2492		if ( ( elem = unmatched[ i ] ) ) {
2493			if ( !filter || filter( elem, context, xml ) ) {
2494				newUnmatched.push( elem );
2495				if ( mapped ) {
2496					map.push( i );
2497				}
2498			}
2499		}
2500	}
2501
2502	return newUnmatched;
2503}
2504
2505function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2506	if ( postFilter && !postFilter[ expando ] ) {
2507		postFilter = setMatcher( postFilter );
2508	}
2509	if ( postFinder && !postFinder[ expando ] ) {
2510		postFinder = setMatcher( postFinder, postSelector );
2511	}
2512	return markFunction( function( seed, results, context, xml ) {
2513		var temp, i, elem,
2514			preMap = [],
2515			postMap = [],
2516			preexisting = results.length,
2517
2518			// Get initial elements from seed or context
2519			elems = seed || multipleContexts(
2520				selector || "*",
2521				context.nodeType ? [ context ] : context,
2522				[]
2523			),
2524
2525			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2526			matcherIn = preFilter && ( seed || !selector ) ?
2527				condense( elems, preMap, preFilter, context, xml ) :
2528				elems,
2529
2530			matcherOut = matcher ?
2531
2532				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2533				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2534
2535					// ...intermediate processing is necessary
2536					[] :
2537
2538					// ...otherwise use results directly
2539					results :
2540				matcherIn;
2541
2542		// Find primary matches
2543		if ( matcher ) {
2544			matcher( matcherIn, matcherOut, context, xml );
2545		}
2546
2547		// Apply postFilter
2548		if ( postFilter ) {
2549			temp = condense( matcherOut, postMap );
2550			postFilter( temp, [], context, xml );
2551
2552			// Un-match failing elements by moving them back to matcherIn
2553			i = temp.length;
2554			while ( i-- ) {
2555				if ( ( elem = temp[ i ] ) ) {
2556					matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
2557				}
2558			}
2559		}
2560
2561		if ( seed ) {
2562			if ( postFinder || preFilter ) {
2563				if ( postFinder ) {
2564
2565					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2566					temp = [];
2567					i = matcherOut.length;
2568					while ( i-- ) {
2569						if ( ( elem = matcherOut[ i ] ) ) {
2570
2571							// Restore matcherIn since elem is not yet a final match
2572							temp.push( ( matcherIn[ i ] = elem ) );
2573						}
2574					}
2575					postFinder( null, ( matcherOut = [] ), temp, xml );
2576				}
2577
2578				// Move matched elements from seed to results to keep them synchronized
2579				i = matcherOut.length;
2580				while ( i-- ) {
2581					if ( ( elem = matcherOut[ i ] ) &&
2582						( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {
2583
2584						seed[ temp ] = !( results[ temp ] = elem );
2585					}
2586				}
2587			}
2588
2589		// Add elements to results, through postFinder if defined
2590		} else {
2591			matcherOut = condense(
2592				matcherOut === results ?
2593					matcherOut.splice( preexisting, matcherOut.length ) :
2594					matcherOut
2595			);
2596			if ( postFinder ) {
2597				postFinder( null, results, matcherOut, xml );
2598			} else {
2599				push.apply( results, matcherOut );
2600			}
2601		}
2602	} );
2603}
2604
2605function matcherFromTokens( tokens ) {
2606	var checkContext, matcher, j,
2607		len = tokens.length,
2608		leadingRelative = Expr.relative[ tokens[ 0 ].type ],
2609		implicitRelative = leadingRelative || Expr.relative[ " " ],
2610		i = leadingRelative ? 1 : 0,
2611
2612		// The foundational matcher ensures that elements are reachable from top-level context(s)
2613		matchContext = addCombinator( function( elem ) {
2614			return elem === checkContext;
2615		}, implicitRelative, true ),
2616		matchAnyContext = addCombinator( function( elem ) {
2617			return indexOf( checkContext, elem ) > -1;
2618		}, implicitRelative, true ),
2619		matchers = [ function( elem, context, xml ) {
2620			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2621				( checkContext = context ).nodeType ?
2622					matchContext( elem, context, xml ) :
2623					matchAnyContext( elem, context, xml ) );
2624
2625			// Avoid hanging onto element (issue #299)
2626			checkContext = null;
2627			return ret;
2628		} ];
2629
2630	for ( ; i < len; i++ ) {
2631		if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
2632			matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
2633		} else {
2634			matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
2635
2636			// Return special upon seeing a positional matcher
2637			if ( matcher[ expando ] ) {
2638
2639				// Find the next relative operator (if any) for proper handling
2640				j = ++i;
2641				for ( ; j < len; j++ ) {
2642					if ( Expr.relative[ tokens[ j ].type ] ) {
2643						break;
2644					}
2645				}
2646				return setMatcher(
2647					i > 1 && elementMatcher( matchers ),
2648					i > 1 && toSelector(
2649
2650					// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2651					tokens
2652						.slice( 0, i - 1 )
2653						.concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
2654					).replace( rtrim, "$1" ),
2655					matcher,
2656					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2657					j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
2658					j < len && toSelector( tokens )
2659				);
2660			}
2661			matchers.push( matcher );
2662		}
2663	}
2664
2665	return elementMatcher( matchers );
2666}
2667
2668function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2669	var bySet = setMatchers.length > 0,
2670		byElement = elementMatchers.length > 0,
2671		superMatcher = function( seed, context, xml, results, outermost ) {
2672			var elem, j, matcher,
2673				matchedCount = 0,
2674				i = "0",
2675				unmatched = seed && [],
2676				setMatched = [],
2677				contextBackup = outermostContext,
2678
2679				// We must always have either seed elements or outermost context
2680				elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ),
2681
2682				// Use integer dirruns iff this is the outermost matcher
2683				dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
2684				len = elems.length;
2685
2686			if ( outermost ) {
2687
2688				// Support: IE 11+, Edge 17 - 18+
2689				// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2690				// two documents; shallow comparisons work.
2691				// eslint-disable-next-line eqeqeq
2692				outermostContext = context == document || context || outermost;
2693			}
2694
2695			// Add elements passing elementMatchers directly to results
2696			// Support: IE<9, Safari
2697			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2698			for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
2699				if ( byElement && elem ) {
2700					j = 0;
2701
2702					// Support: IE 11+, Edge 17 - 18+
2703					// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2704					// two documents; shallow comparisons work.
2705					// eslint-disable-next-line eqeqeq
2706					if ( !context && elem.ownerDocument != document ) {
2707						setDocument( elem );
2708						xml = !documentIsHTML;
2709					}
2710					while ( ( matcher = elementMatchers[ j++ ] ) ) {
2711						if ( matcher( elem, context || document, xml ) ) {
2712							results.push( elem );
2713							break;
2714						}
2715					}
2716					if ( outermost ) {
2717						dirruns = dirrunsUnique;
2718					}
2719				}
2720
2721				// Track unmatched elements for set filters
2722				if ( bySet ) {
2723
2724					// They will have gone through all possible matchers
2725					if ( ( elem = !matcher && elem ) ) {
2726						matchedCount--;
2727					}
2728
2729					// Lengthen the array for every element, matched or not
2730					if ( seed ) {
2731						unmatched.push( elem );
2732					}
2733				}
2734			}
2735
2736			// `i` is now the count of elements visited above, and adding it to `matchedCount`
2737			// makes the latter nonnegative.
2738			matchedCount += i;
2739
2740			// Apply set filters to unmatched elements
2741			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2742			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2743			// no element matchers and no seed.
2744			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2745			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2746			// numerically zero.
2747			if ( bySet && i !== matchedCount ) {
2748				j = 0;
2749				while ( ( matcher = setMatchers[ j++ ] ) ) {
2750					matcher( unmatched, setMatched, context, xml );
2751				}
2752
2753				if ( seed ) {
2754
2755					// Reintegrate element matches to eliminate the need for sorting
2756					if ( matchedCount > 0 ) {
2757						while ( i-- ) {
2758							if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
2759								setMatched[ i ] = pop.call( results );
2760							}
2761						}
2762					}
2763
2764					// Discard index placeholder values to get only actual matches
2765					setMatched = condense( setMatched );
2766				}
2767
2768				// Add matches to results
2769				push.apply( results, setMatched );
2770
2771				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2772				if ( outermost && !seed && setMatched.length > 0 &&
2773					( matchedCount + setMatchers.length ) > 1 ) {
2774
2775					Sizzle.uniqueSort( results );
2776				}
2777			}
2778
2779			// Override manipulation of globals by nested matchers
2780			if ( outermost ) {
2781				dirruns = dirrunsUnique;
2782				outermostContext = contextBackup;
2783			}
2784
2785			return unmatched;
2786		};
2787
2788	return bySet ?
2789		markFunction( superMatcher ) :
2790		superMatcher;
2791}
2792
2793compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2794	var i,
2795		setMatchers = [],
2796		elementMatchers = [],
2797		cached = compilerCache[ selector + " " ];
2798
2799	if ( !cached ) {
2800
2801		// Generate a function of recursive functions that can be used to check each element
2802		if ( !match ) {
2803			match = tokenize( selector );
2804		}
2805		i = match.length;
2806		while ( i-- ) {
2807			cached = matcherFromTokens( match[ i ] );
2808			if ( cached[ expando ] ) {
2809				setMatchers.push( cached );
2810			} else {
2811				elementMatchers.push( cached );
2812			}
2813		}
2814
2815		// Cache the compiled function
2816		cached = compilerCache(
2817			selector,
2818			matcherFromGroupMatchers( elementMatchers, setMatchers )
2819		);
2820
2821		// Save selector and tokenization
2822		cached.selector = selector;
2823	}
2824	return cached;
2825};
2826
2827/**
2828 * A low-level selection function that works with Sizzle's compiled
2829 *  selector functions
2830 * @param {String|Function} selector A selector or a pre-compiled
2831 *  selector function built with Sizzle.compile
2832 * @param {Element} context
2833 * @param {Array} [results]
2834 * @param {Array} [seed] A set of elements to match against
2835 */
2836select = Sizzle.select = function( selector, context, results, seed ) {
2837	var i, tokens, token, type, find,
2838		compiled = typeof selector === "function" && selector,
2839		match = !seed && tokenize( ( selector = compiled.selector || selector ) );
2840
2841	results = results || [];
2842
2843	// Try to minimize operations if there is only one selector in the list and no seed
2844	// (the latter of which guarantees us context)
2845	if ( match.length === 1 ) {
2846
2847		// Reduce context if the leading compound selector is an ID
2848		tokens = match[ 0 ] = match[ 0 ].slice( 0 );
2849		if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
2850			context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
2851
2852			context = ( Expr.find[ "ID" ]( token.matches[ 0 ]
2853				.replace( runescape, funescape ), context ) || [] )[ 0 ];
2854			if ( !context ) {
2855				return results;
2856
2857			// Precompiled matchers will still verify ancestry, so step up a level
2858			} else if ( compiled ) {
2859				context = context.parentNode;
2860			}
2861
2862			selector = selector.slice( tokens.shift().value.length );
2863		}
2864
2865		// Fetch a seed set for right-to-left matching
2866		i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length;
2867		while ( i-- ) {
2868			token = tokens[ i ];
2869
2870			// Abort if we hit a combinator
2871			if ( Expr.relative[ ( type = token.type ) ] ) {
2872				break;
2873			}
2874			if ( ( find = Expr.find[ type ] ) ) {
2875
2876				// Search, expanding context for leading sibling combinators
2877				if ( ( seed = find(
2878					token.matches[ 0 ].replace( runescape, funescape ),
2879					rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||
2880						context
2881				) ) ) {
2882
2883					// If seed is empty or no tokens remain, we can return early
2884					tokens.splice( i, 1 );
2885					selector = seed.length && toSelector( tokens );
2886					if ( !selector ) {
2887						push.apply( results, seed );
2888						return results;
2889					}
2890
2891					break;
2892				}
2893			}
2894		}
2895	}
2896
2897	// Compile and execute a filtering function if one is not provided
2898	// Provide `match` to avoid retokenization if we modified the selector above
2899	( compiled || compile( selector, match ) )(
2900		seed,
2901		context,
2902		!documentIsHTML,
2903		results,
2904		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2905	);
2906	return results;
2907};
2908
2909// One-time assignments
2910
2911// Sort stability
2912support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
2913
2914// Support: Chrome 14-35+
2915// Always assume duplicates if they aren't passed to the comparison function
2916support.detectDuplicates = !!hasDuplicate;
2917
2918// Initialize against the default document
2919setDocument();
2920
2921// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2922// Detached nodes confoundingly follow *each other*
2923support.sortDetached = assert( function( el ) {
2924
2925	// Should return 1, but returns 4 (following)
2926	return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
2927} );
2928
2929// Support: IE<8
2930// Prevent attribute/property "interpolation"
2931// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2932if ( !assert( function( el ) {
2933	el.innerHTML = "<a href='#'></a>";
2934	return el.firstChild.getAttribute( "href" ) === "#";
2935} ) ) {
2936	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2937		if ( !isXML ) {
2938			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2939		}
2940	} );
2941}
2942
2943// Support: IE<9
2944// Use defaultValue in place of getAttribute("value")
2945if ( !support.attributes || !assert( function( el ) {
2946	el.innerHTML = "<input/>";
2947	el.firstChild.setAttribute( "value", "" );
2948	return el.firstChild.getAttribute( "value" ) === "";
2949} ) ) {
2950	addHandle( "value", function( elem, _name, isXML ) {
2951		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2952			return elem.defaultValue;
2953		}
2954	} );
2955}
2956
2957// Support: IE<9
2958// Use getAttributeNode to fetch booleans when getAttribute lies
2959if ( !assert( function( el ) {
2960	return el.getAttribute( "disabled" ) == null;
2961} ) ) {
2962	addHandle( booleans, function( elem, name, isXML ) {
2963		var val;
2964		if ( !isXML ) {
2965			return elem[ name ] === true ? name.toLowerCase() :
2966				( val = elem.getAttributeNode( name ) ) && val.specified ?
2967					val.value :
2968					null;
2969		}
2970	} );
2971}
2972
2973return Sizzle;
2974
2975} )( window );
2976
2977
2978
2979jQuery.find = Sizzle;
2980jQuery.expr = Sizzle.selectors;
2981
2982// Deprecated
2983jQuery.expr[ ":" ] = jQuery.expr.pseudos;
2984jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2985jQuery.text = Sizzle.getText;
2986jQuery.isXMLDoc = Sizzle.isXML;
2987jQuery.contains = Sizzle.contains;
2988jQuery.escapeSelector = Sizzle.escape;
2989
2990
2991
2992
2993var dir = function( elem, dir, until ) {
2994	var matched = [],
2995		truncate = until !== undefined;
2996
2997	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
2998		if ( elem.nodeType === 1 ) {
2999			if ( truncate && jQuery( elem ).is( until ) ) {
3000				break;
3001			}
3002			matched.push( elem );
3003		}
3004	}
3005	return matched;
3006};
3007
3008
3009var siblings = function( n, elem ) {
3010	var matched = [];
3011
3012	for ( ; n; n = n.nextSibling ) {
3013		if ( n.nodeType === 1 && n !== elem ) {
3014			matched.push( n );
3015		}
3016	}
3017
3018	return matched;
3019};
3020
3021
3022var rneedsContext = jQuery.expr.match.needsContext;
3023
3024
3025
3026function nodeName( elem, name ) {
3027