https://confirming-factoring.santander.com.co/factoring/common/js/jquery.js

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

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

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

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

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