https://www.purposeprize.org/Scripts/commonCmsBundle?v=SXPdq0ElpST07gCtqjSKHwRQcZ4

1/* input(62763,45255-45262): run-time error JS1010: Expected identifier: finally */
2/*!
3 * jQuery JavaScript Library v3.6.0
4 * https://jquery.com/
5 *
6 * Includes Sizzle.js
7 * https://sizzlejs.com/
8 *
9 * Copyright OpenJS Foundation and other contributors
10 * Released under the MIT license
11 * https://jquery.org/license
12 *
13 * Date: 2021-03-02T17:08Z
14 */
15( function( global, factory ) {
16
17	"use strict";
18
19	if ( typeof module === "object" && typeof module.exports === "object" ) {
20
21		// For CommonJS and CommonJS-like environments where a proper `window`
22		// is present, execute the factory and get jQuery.
23		// For environments that do not have a `window` with a `document`
24		// (such as Node.js), expose a factory as module.exports.
25		// This accentuates the need for the creation of a real `window`.
26		// e.g. var jQuery = require("jquery")(window);
27		// See ticket #14549 for more info.
28		module.exports = global.document ?
29			factory( global, true ) :
30			function( w ) {
31				if ( !w.document ) {
32					throw new Error( "jQuery requires a window with a document" );
33				}
34				return factory( w );
35			};
36	} else {
37		factory( global );
38	}
39
40// Pass this if window is not defined yet
41} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
42
43// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
44// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
45// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
46// enough that all such attempts are guarded in a try block.
47"use strict";
48
49var arr = [];
50
51var getProto = Object.getPrototypeOf;
52
53var slice = arr.slice;
54
55var flat = arr.flat ? function( array ) {
56	return arr.flat.call( array );
57} : function( array ) {
58	return arr.concat.apply( [], array );
59};
60
61
62var push = arr.push;
63
64var indexOf = arr.indexOf;
65
66var class2type = {};
67
68var toString = class2type.toString;
69
70var hasOwn = class2type.hasOwnProperty;
71
72var fnToString = hasOwn.toString;
73
74var ObjectFunctionString = fnToString.call( Object );
75
76var support = {};
77
78var isFunction = function isFunction( obj ) {
79
80		// Support: Chrome <=57, Firefox <=52
81		// In some browsers, typeof returns "function" for HTML <object> elements
82		// (i.e., `typeof document.createElement( "object" ) === "function"`).
83		// We don't want to classify *any* DOM node as a function.
84		// Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5
85		// Plus for old WebKit, typeof returns "function" for HTML collections
86		// (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756)
87		return typeof obj === "function" && typeof obj.nodeType !== "number" &&
88			typeof obj.item !== "function";
89	};
90
91
92var isWindow = function isWindow( obj ) {
93		return obj != null && obj === obj.window;
94	};
95
96
97var document = window.document;
98
99
100
101	var preservedScriptAttributes = {
102		type: true,
103		src: true,
104		nonce: true,
105		noModule: true
106	};
107
108	function DOMEval( code, node, doc ) {
109		doc = doc || document;
110
111		var i, val,
112			script = doc.createElement( "script" );
113
114		script.text = code;
115		if ( node ) {
116			for ( i in preservedScriptAttributes ) {
117
118				// Support: Firefox 64+, Edge 18+
119				// Some browsers don't support the "nonce" property on scripts.
120				// On the other hand, just using `getAttribute` is not enough as
121				// the `nonce` attribute is reset to an empty string whenever it
122				// becomes browsing-context connected.
123				// See https://github.com/whatwg/html/issues/2369
124				// See https://html.spec.whatwg.org/#nonce-attributes
125				// The `node.getAttribute` check was added for the sake of
126				// `jQuery.globalEval` so that it can fake a nonce-containing node
127				// via an object.
128				val = node[ i ] || node.getAttribute && node.getAttribute( i );
129				if ( val ) {
130					script.setAttribute( i, val );
131				}
132			}
133		}
134		doc.head.appendChild( script ).parentNode.removeChild( script );
135	}
136
137
138function toType( obj ) {
139	if ( obj == null ) {
140		return obj + "";
141	}
142
143	// Support: Android <=2.3 only (functionish RegExp)
144	return typeof obj === "object" || typeof obj === "function" ?
145		class2type[ toString.call( obj ) ] || "object" :
146		typeof obj;
147}
148/* global Symbol */
149// Defining this global in .eslintrc.json would create a danger of using the global
150// unguarded in another place, it seems safer to define global only for this module
151
152
153
154var
155	version = "hidden",
156
157	// Define a local copy of jQuery
158	jQuery = function( selector, context ) {
159
160		// The jQuery object is actually just the init constructor 'enhanced'
161		// Need init if jQuery is called (just allow error to be thrown if not included)
162		return new jQuery.fn.init( selector, context );
163	};
164
165jQuery.fn = jQuery.prototype = {
166
167	// The current version of jQuery being used
168	jquery: version,
169
170	constructor: jQuery,
171
172	// The default length of a jQuery object is 0
173	length: 0,
174
175	toArray: function() {
176		return slice.call( this );
177	},
178
179	// Get the Nth element in the matched element set OR
180	// Get the whole matched element set as a clean array
181	get: function( num ) {
182
183		// Return all the elements in a clean array
184		if ( num == null ) {
185			return slice.call( this );
186		}
187
188		// Return just the one element from the set
189		return num < 0 ? this[ num + this.length ] : this[ num ];
190	},
191
192	// Take an array of elements and push it onto the stack
193	// (returning the new matched element set)
194	pushStack: function( elems ) {
195
196		// Build a new jQuery matched element set
197		var ret = jQuery.merge( this.constructor(), elems );
198
199		// Add the old object onto the stack (as a reference)
200		ret.prevObject = this;
201
202		// Return the newly-formed element set
203		return ret;
204	},
205
206	// Execute a callback for every element in the matched set.
207	each: function( callback ) {
208		return jQuery.each( this, callback );
209	},
210
211	map: function( callback ) {
212		return this.pushStack( jQuery.map( this, function( elem, i ) {
213			return callback.call( elem, i, elem );
214		} ) );
215	},
216
217	slice: function() {
218		return this.pushStack( slice.apply( this, arguments ) );
219	},
220
221	first: function() {
222		return this.eq( 0 );
223	},
224
225	last: function() {
226		return this.eq( -1 );
227	},
228
229	even: function() {
230		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
231			return ( i + 1 ) % 2;
232		} ) );
233	},
234
235	odd: function() {
236		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
237			return i % 2;
238		} ) );
239	},
240
241	eq: function( i ) {
242		var len = this.length,
243			j = +i + ( i < 0 ? len : 0 );
244		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
245	},
246
247	end: function() {
248		return this.prevObject || this.constructor();
249	},
250
251	// For internal use only.
252	// Behaves like an Array's method, not like a jQuery method.
253	push: push,
254	sort: arr.sort,
255	splice: arr.splice
256};
257
258jQuery.extend = jQuery.fn.extend = function() {
259	var options, name, src, copy, copyIsArray, clone,
260		target = arguments[ 0 ] || {},
261		i = 1,
262		length = arguments.length,
263		deep = false;
264
265	// Handle a deep copy situation
266	if ( typeof target === "boolean" ) {
267		deep = target;
268
269		// Skip the boolean and the target
270		target = arguments[ i ] || {};
271		i++;
272	}
273
274	// Handle case when target is a string or something (possible in deep copy)
275	if ( typeof target !== "object" && !isFunction( target ) ) {
276		target = {};
277	}
278
279	// Extend jQuery itself if only one argument is passed
280	if ( i === length ) {
281		target = this;
282		i--;
283	}
284
285	for ( ; i < length; i++ ) {
286
287		// Only deal with non-null/undefined values
288		if ( ( options = arguments[ i ] ) != null ) {
289
290			// Extend the base object
291			for ( name in options ) {
292				copy = options[ name ];
293
294				// Prevent Object.prototype pollution
295				// Prevent never-ending loop
296				if ( name === "__proto__" || target === copy ) {
297					continue;
298				}
299
300				// Recurse if we're merging plain objects or arrays
301				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
302					( copyIsArray = Array.isArray( copy ) ) ) ) {
303					src = target[ name ];
304
305					// Ensure proper type for the source value
306					if ( copyIsArray && !Array.isArray( src ) ) {
307						clone = [];
308					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
309						clone = {};
310					} else {
311						clone = src;
312					}
313					copyIsArray = false;
314
315					// Never move original objects, clone them
316					target[ name ] = jQuery.extend( deep, clone, copy );
317
318				// Don't bring in undefined values
319				} else if ( copy !== undefined ) {
320					target[ name ] = copy;
321				}
322			}
323		}
324	}
325
326	// Return the modified object
327	return target;
328};
329
330jQuery.extend( {
331
332	// Unique for each copy of jQuery on the page
333	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
334
335	// Assume jQuery is ready without the ready module
336	isReady: true,
337
338	error: function( msg ) {
339		throw new Error( msg );
340	},
341
342	noop: function() {},
343
344	isPlainObject: function( obj ) {
345		var proto, Ctor;
346
347		// Detect obvious negatives
348		// Use toString instead of jQuery.type to catch host objects
349		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
350			return false;
351		}
352
353		proto = getProto( obj );
354
355		// Objects with no prototype (e.g., `Object.create( null )`) are plain
356		if ( !proto ) {
357			return true;
358		}
359
360		// Objects with prototype are plain iff they were constructed by a global Object function
361		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
362		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
363	},
364
365	isEmptyObject: function( obj ) {
366		var name;
367
368		for ( name in obj ) {
369			return false;
370		}
371		return true;
372	},
373
374	// Evaluates a script in a provided context; falls back to the global one
375	// if not specified.
376	globalEval: function( code, options, doc ) {
377		DOMEval( code, { nonce: options && options.nonce }, doc );
378	},
379
380	each: function( obj, callback ) {
381		var length, i = 0;
382
383		if ( isArrayLike( obj ) ) {
384			length = obj.length;
385			for ( ; i < length; i++ ) {
386				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
387					break;
388				}
389			}
390		} else {
391			for ( i in obj ) {
392				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
393					break;
394				}
395			}
396		}
397
398		return obj;
399	},
400
401	// results is for internal usage only
402	makeArray: function( arr, results ) {
403		var ret = results || [];
404
405		if ( arr != null ) {
406			if ( isArrayLike( Object( arr ) ) ) {
407				jQuery.merge( ret,
408					typeof arr === "string" ?
409						[ arr ] : arr
410				);
411			} else {
412				push.call( ret, arr );
413			}
414		}
415
416		return ret;
417	},
418
419	inArray: function( elem, arr, i ) {
420		return arr == null ? -1 : indexOf.call( arr, elem, i );
421	},
422
423	// Support: Android <=4.0 only, PhantomJS 1 only
424	// push.apply(_, arraylike) throws on ancient WebKit
425	merge: function( first, second ) {
426		var len = +second.length,
427			j = 0,
428			i = first.length;
429
430		for ( ; j < len; j++ ) {
431			first[ i++ ] = second[ j ];
432		}
433
434		first.length = i;
435
436		return first;
437	},
438
439	grep: function( elems, callback, invert ) {
440		var callbackInverse,
441			matches = [],
442			i = 0,
443			length = elems.length,
444			callbackExpect = !invert;
445
446		// Go through the array, only saving the items
447		// that pass the validator function
448		for ( ; i < length; i++ ) {
449			callbackInverse = !callback( elems[ i ], i );
450			if ( callbackInverse !== callbackExpect ) {
451				matches.push( elems[ i ] );
452			}
453		}
454
455		return matches;
456	},
457
458	// arg is for internal usage only
459	map: function( elems, callback, arg ) {
460		var length, value,
461			i = 0,
462			ret = [];
463
464		// Go through the array, translating each of the items to their new values
465		if ( isArrayLike( elems ) ) {
466			length = elems.length;
467			for ( ; i < length; i++ ) {
468				value = callback( elems[ i ], i, arg );
469
470				if ( value != null ) {

471					ret.push( value );
472				}
473			}
474
475		// Go through every key on the object,
476		} else {
477			for ( i in elems ) {
478				value = callback( elems[ i ], i, arg );
479
480				if ( value != null ) {
481					ret.push( value );
482				}
483			}
484		}
485
486		// Flatten any nested arrays
487		return flat( ret );
488	},
489
490	// A global GUID counter for objects
491	guid: 1,
492
493	// jQuery.support is not used in Core but other projects attach their
494	// properties to it so it needs to exist.
495	support: support
496} );
497
498if ( typeof Symbol === "function" ) {
499	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
500}
501
502// Populate the class2type map
503jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
504	function( _i, name ) {
505		class2type[ "[object " + name + "]" ] = name.toLowerCase();
506	} );
507
508function isArrayLike( obj ) {
509
510	// Support: real iOS 8.2 only (not reproducible in simulator)
511	// `in` check used to prevent JIT error (gh-2145)
512	// hasOwn isn't used here due to false negatives
513	// regarding Nodelist length in IE
514	var length = !!obj && "length" in obj && obj.length,
515		type = toType( obj );
516
517	if ( isFunction( obj ) || isWindow( obj ) ) {
518		return false;
519	}
520
521	return type === "array" || length === 0 ||
522		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
523}
524var Sizzle =
525/*!
526 * Sizzle CSS Selector Engine v2.3.6
527 * https://sizzlejs.com/
528 *
529 * Copyright JS Foundation and other contributors
530 * Released under the MIT license
531 * https://js.foundation/
532 *
533 * Date: 2021-02-16
534 */
535( function( window ) {
536var i,
537	support,
538	Expr,
539	getText,
540	isXML,
541	tokenize,
542	compile,
543	select,
544	outermostContext,
545	sortInput,
546	hasDuplicate,
547
548	// Local document vars
549	setDocument,
550	document,
551	docElem,
552	documentIsHTML,
553	rbuggyQSA,
554	rbuggyMatches,
555	matches,
556	contains,
557
558	// Instance-specific data
559	expando = "sizzle" + 1 * new Date(),
560	preferredDoc = window.document,
561	dirruns = 0,
562	done = 0,
563	classCache = createCache(),
564	tokenCache = createCache(),
565	compilerCache = createCache(),
566	nonnativeSelectorCache = createCache(),
567	sortOrder = function( a, b ) {
568		if ( a === b ) {
569			hasDuplicate = true;
570		}
571		return 0;
572	},
573
574	// Instance methods
575	hasOwn = ( {} ).hasOwnProperty,
576	arr = [],
577	pop = arr.pop,
578	pushNative = arr.push,
579	push = arr.push,
580	slice = arr.slice,
581
582	// Use a stripped-down indexOf as it's faster than native
583	// https://jsperf.com/thor-indexof-vs-for/5
584	indexOf = function( list, elem ) {
585		var i = 0,
586			len = list.length;
587		for ( ; i < len; i++ ) {
588			if ( list[ i ] === elem ) {
589				return i;
590			}
591		}
592		return -1;
593	},
594
595	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
596		"ismap|loop|multiple|open|readonly|required|scoped",
597
598	// Regular expressions
599
600	// http://www.w3.org/TR/css3-selectors/#whitespace
601	whitespace = "[\\x20\\t\\r\\n\\f]",
602
603	// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
604	identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
605		"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
606
607	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
608	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
609
610		// Operator (capture 2)
611		"*([*^$|!~]?=)" + whitespace +
612
613		// "Attribute values must be CSS identifiers [capture 5]
614		// or strings [capture 3 or capture 4]"
615		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
616		whitespace + "*\\]",
617
618	pseudos = ":(" + identifier + ")(?:\\((" +
619
620		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
621		// 1. quoted (capture 3; capture 4 or capture 5)
622		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
623
624		// 2. simple (capture 6)
625		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
626
627		// 3. anything else (capture 2)
628		".*" +
629		")\\)|)",
630
631	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
632	rwhitespace = new RegExp( whitespace + "+", "g" ),
633	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
634		whitespace + "+$", "g" ),
635
636	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
637	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
638		"*" ),

639	rdescend = new RegExp( whitespace + "|>" ),
640
641	rpseudo = new RegExp( pseudos ),
642	ridentifier = new RegExp( "^" + identifier + "$" ),
643
644	matchExpr = {
645		"ID": new RegExp( "^#(" + identifier + ")" ),
646		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
647		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
648		"ATTR": new RegExp( "^" + attributes ),
649		"PSEUDO": new RegExp( "^" + pseudos ),
650		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
651			whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
652			whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
653		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
654
655		// For use in libraries implementing .is()
656		// We use this for POS matching in `select`
657		"needsContext": new RegExp( "^" + whitespace +
658			"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
659			"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
660	},
661
662	rhtml = /HTML$/i,
663	rinputs = /^(?:input|select|textarea|button)$/i,
664	rheader = /^h\d$/i,
665
666	rnative = /^[^{]+\{\s*\[native \w/,
667
668	// Easily-parseable/retrievable ID or TAG or CLASS selectors
669	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
670
671	rsibling = /[+~]/,
672
673	// CSS escapes
674	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
675	runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
676	funescape = function( escape, nonHex ) {
677		var high = "0x" + escape.slice( 1 ) - 0x10000;
678
679		return nonHex ?
680
681			// Strip the backslash prefix from a non-hex escape sequence
682			nonHex :
683
684			// Replace a hexadecimal escape sequence with the encoded Unicode code point
685			// Support: IE <=11+
686			// For values outside the Basic Multilingual Plane (BMP), manually construct a
687			// surrogate pair
688			high < 0 ?
689				String.fromCharCode( high + 0x10000 ) :
690				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
691	},
692
693	// CSS string/identifier serialization
694	// https://drafts.csswg.org/cssom/#common-serializing-idioms
695	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
696	fcssescape = function( ch, asCodePoint ) {
697		if ( asCodePoint ) {
698
699			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
700			if ( ch === "\0" ) {
701				return "\uFFFD";
702			}
703
704			// Control characters and (dependent upon position) numbers get escaped as code points
705			return ch.slice( 0, -1 ) + "\\" +
706				ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
707		}
708
709		// Other potentially-special ASCII characters get backslash-escaped
710		return "\\" + ch;
711	},
712
713	// Used for iframes
714	// See setDocument()
715	// Removing the function wrapper causes a "Permission Denied"
716	// error in IE
717	unloadHandler = function() {
718		setDocument();
719	},
720
721	inDisabledFieldset = addCombinator(
722		function( elem ) {
723			return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
724		},
725		{ dir: "parentNode", next: "legend" }
726	);
727
728// Optimize for push.apply( _, NodeList )
729try {
730	push.apply(
731		( arr = slice.call( preferredDoc.childNodes ) ),
732		preferredDoc.childNodes
733	);
734
735	// Support: Android<4.0
736	// Detect silently failing push.apply
737	// eslint-disable-next-line no-unused-expressions
738	arr[ preferredDoc.childNodes.length ].nodeType;
739} catch ( e ) {
740	push = { apply: arr.length ?
741
742		// Leverage slice if possible
743		function( target, els ) {
744			pushNative.apply( target, slice.call( els ) );
745		} :
746
747		// Support: IE<9
748		// Otherwise append directly
749		function( target, els ) {
750			var j = target.length,
751				i = 0;
752
753			// Can't trust NodeList.length
754			while ( ( target[ j++ ] = els[ i++ ] ) ) {}
755			target.length = j - 1;
756		}
757	};
758}
759
760function Sizzle( selector, context, results, seed ) {
761	var m, i, elem, nid, match, groups, newSelector,
762		newContext = context && context.ownerDocument,
763
764		// nodeType defaults to 9, since context defaults to document
765		nodeType = context ? context.nodeType : 9;
766
767	results = results || [];
768
769	// Return early from calls with invalid selector or context
770	if ( typeof selector !== "string" || !selector ||
771		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
772
773		return results;
774	}
775
776	// Try to shortcut find operations (as opposed to filters) in HTML documents
777	if ( !seed ) {
778		setDocument( context );
779		context = context || document;
780
781		if ( documentIsHTML ) {
782
783			// If the selector is sufficiently simple, try using a "get*By*" DOM method
784			// (excepting DocumentFragment context, where the methods don't exist)
785			if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
786
787				// ID selector
788				if ( ( m = match[ 1 ] ) ) {
789
790					// Document context
791					if ( nodeType === 9 ) {
792						if ( ( elem = context.getElementById( m ) ) ) {
793

944	} finally {
945
946		// Remove from its parent by default
947		if ( el.parentNode ) {
948			el.parentNode.removeChild( el );
949		}
950
951		// release memory in IE
952		el = null;
953	}
954}
955
956/**
957 * Adds the same handler for all of the specified attrs
958 * @param {String} attrs Pipe-separated list of attributes
959 * @param {Function} handler The method that will be applied
960 */
961function addHandle( attrs, handler ) {
962	var arr = attrs.split( "|" ),
963		i = arr.length;
964
965	while ( i-- ) {
966		Expr.attrHandle[ arr[ i ] ] = handler;
967	}
968}
969
970/**
971 * Checks document order of two siblings
972 * @param {Element} a
973 * @param {Element} b
974 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
975 */
976function siblingCheck( a, b ) {
977	var cur = b && a,
978		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
979			a.sourceIndex - b.sourceIndex;
980
981	// Use IE sourceIndex if available on both nodes
982	if ( diff ) {
983		return diff;
984	}
985
986	// Check if b follows a
987	if ( cur ) {
988		while ( ( cur = cur.nextSibling ) ) {
989			if ( cur === b ) {
990				return -1;
991			}
992		}
993	}
994
995	return a ? 1 : -1;
996}
997
998/**
999 * Returns a function to use in pseudos for input types
1000 * @param {String} type
1001 */
1002function createInputPseudo( type ) {
1003	return function( elem ) {
1004		var name = elem.nodeName.toLowerCase();
1005		return name === "input" && elem.type === type;
1006	};
1007}
1008
1009/**
1010 * Returns a function to use in pseudos for buttons
1011 * @param {String} type
1012 */
1013function createButtonPseudo( type ) {
1014	return function( elem ) {
1015		var name = elem.nodeName.toLowerCase();
1016		return ( name === "input" || name === "button" ) && elem.type === type;
1017	};
1018}
1019
1020/**
1021 * Returns a function to use in pseudos for :enabled/:disabled
1022 * @param {Boolean} disabled true for :disabled; false for :enabled
1023 */
1024function createDisabledPseudo( disabled ) {
1025
1026	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1027	return function( elem ) {
1028
1029		// Only certain elements can match :enabled or :disabled
1030		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1031		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1032		if ( "form" in elem ) {
1033
1034			// Check for inherited disabledness on relevant non-disabled elements:
1035			// * listed form-associated elements in a disabled fieldset
1036			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
1037			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1038			// * option elements in a disabled optgroup
1039			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1040			// All such elements have a "form" property.
1041			if ( elem.parentNode && elem.disabled === false ) {
1042
1043				// Option elements defer to a parent optgroup if present
1044				if ( "label" in elem ) {
1045					if ( "label" in elem.parentNode ) {
1046						return elem.parentNode.disabled === disabled;
1047					} else {
1048						return elem.disabled === disabled;
1049					}
1050				}
1051
1052				// Support: IE 6 - 11
1053				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
1054				return elem.isDisabled === disabled ||
1055
1056					// Where there is no isDisabled, check manually
1057					/* jshint -W018 */
1058					elem.isDisabled !== !disabled &&
1059					inDisabledFieldset( elem ) === disabled;
1060			}
1061
1062			return elem.disabled === disabled;
1063
1064		// Try to winnow out elements that can't be disabled before trusting the disabled property.
1065		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1066		// even exist on them, let alone have a boolean value.
1067		} else if ( "label" in elem ) {
1068			return elem.disabled === disabled;
1069		}
1070
1071		// Remaining elements are neither :enabled nor :disabled
1072		return false;
1073	};
1074}
1075
1076/**
1077 * Returns a function to use in pseudos for positionals
1078 * @param {Function} fn
1079 */
1080function createPositionalPseudo( fn ) {
1081	return markFunction( function( argument ) {
1082		argument = +argument;
1083		return markFunction( function( seed, matches ) {
1084			var j,
1085				matchIndexes = fn( [], seed.length, argument ),
1086				i = matchIndexes.length;
1087
1088			// Match elements found at the specified indexes
1089			while ( i-- ) {
1090				if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
1091					seed[ j ] = !( matches[ j ] = seed[ j ] );
1092				}
1093			}
1094		} );
1095	} );
1096}
1097
1098/**
1099 * Checks a node for validity as a Sizzle context

1234		// Support: IE 6 - 7 only
1235		// getElementById is not reliable as a find shortcut
1236		Expr.find[ "ID" ] = function( id, context ) {
1237			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1238				var node, i, elems,
1239					elem = context.getElementById( id );
1240
1241				if ( elem ) {
1242
1243					// Verify the id attribute
1244					node = elem.getAttributeNode( "id" );
1245					if ( node && node.value === id ) {
1246						return [ elem ];
1247					}
1248
1249					// Fall back on getElementsByName
1250					elems = context.getElementsByName( id );
1251					i = 0;
1252					while ( ( elem = elems[ i++ ] ) ) {
1253						node = elem.getAttributeNode( "id" );
1254						if ( node && node.value === id ) {
1255							return [ elem ];
1256						}
1257					}
1258				}
1259
1260				return [];
1261			}
1262		};
1263	}
1264
1265	// Tag
1266	Expr.find[ "TAG" ] = support.getElementsByTagName ?
1267		function( tag, context ) {
1268			if ( typeof context.getElementsByTagName !== "undefined" ) {
1269				return context.getElementsByTagName( tag );
1270
1271			// DocumentFragment nodes don't have gEBTN
1272			} else if ( support.qsa ) {
1273				return context.querySelectorAll( tag );
1274			}
1275		} :
1276
1277		function( tag, context ) {
1278			var elem,
1279				tmp = [],
1280				i = 0,
1281
1282				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1283				results = context.getElementsByTagName( tag );
1284
1285			// Filter out possible comments
1286			if ( tag === "*" ) {
1287				while ( ( elem = results[ i++ ] ) ) {
1288					if ( elem.nodeType === 1 ) {
1289						tmp.push( elem );
1290					}
1291				}
1292
1293				return tmp;
1294			}
1295			return results;
1296		};
1297
1298	// Class
1299	Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) {
1300		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1301			return context.getElementsByClassName( className );
1302		}
1303	};
1304
1305	/* QSA/matchesSelector
1306	---------------------------------------------------------------------- */
1307
1308	// QSA and matchesSelector support
1309
1310	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1311	rbuggyMatches = [];
1312
1313	// qSa(:focus) reports false when true (Chrome 21)
1314	// We allow this because of a bug in IE8/9 that throws an error
1315	// whenever `document.activeElement` is accessed on an iframe
1316	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1317	// See https://bugs.jquery.com/ticket/13378
1318	rbuggyQSA = [];
1319
1320	if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {
1321
1322		// Build QSA regex
1323		// Regex strategy adopted from Diego Perini
1324		assert( function( el ) {
1325
1326			var input;
1327
1328			// Select is set to empty string on purpose
1329			// This is to test IE's treatment of not explicitly
1330			// setting a boolean content attribute,
1331			// since its presence should be enough
1332			// https://bugs.jquery.com/ticket/12359
1333			docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
1334				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
1335				"<option selected=''></option></select>";
1336
1337			// Support: IE8, Opera 11-12.16
1338			// Nothing should be selected when empty strings follow ^= or $= or *=
1339			// The test attribute must be unknown in Opera but "safe" for WinRT
1340			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1341			if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) {
1342				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1343			}
1344
1345			// Support: IE8
1346			// Boolean attributes and "value" are not treated correctly
1347			if ( !el.querySelectorAll( "[selected]" ).length ) {
1348				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1349			}
1350
1351			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1352			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1353				rbuggyQSA.push( "~=" );
1354			}
1355
1356			// Support: IE 11+, Edge 15 - 18+
1357			// IE 11/Edge don't find elements on a `[name='']` query in some cases.
1358			// Adding a temporary attribute to the document before the selection works
1359			// around the issue.
1360			// Interestingly, IE 10 & older don't seem to have the issue.
1361			input = document.createElement( "input" );
1362			input.setAttribute( "name", "" );
1363			el.appendChild( input );
1364			if ( !el.querySelectorAll( "[name='']" ).length ) {
1365				rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" 

1365+
1366					whitespace + "*(?:''|\"\")" );
1367			}
1368
1369			// Webkit/Opera - :checked should return selected option elements
1370			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1371			// IE8 throws error here and will not see later tests
1372			if ( !el.querySelectorAll( ":checked" ).length ) {
1373				rbuggyQSA.push( ":checked" );
1374			}
1375
1376			// Support: Safari 8+, iOS 8+
1377			// https://bugs.webkit.org/show_bug.cgi?id=136851
1378			// In-page `selector#id sibling-combinator selector` fails
1379			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
1380				rbuggyQSA.push( ".#.+[+~]" );
1381			}
1382
1383			// Support: Firefox <=3.6 - 5 only
1384			// Old Firefox doesn't throw on a badly-escaped identifier.
1385			el.querySelectorAll( "\\\f" );
1386			rbuggyQSA.push( "[\\r\\n\\f]" );
1387		} );
1388
1389		assert( function( el ) {
1390			el.innerHTML = "<a href='' disabled='disabled'></a>" +
1391				"<select disabled='disabled'><option/></select>";
1392
1393			// Support: Windows 8 Native Apps
1394			// The type and name attributes are restricted during .innerHTML assignment
1395			var input = document.createElement( "input" );
1396			input.setAttribute( "type", "hidden" );
1397			el.appendChild( input ).setAttribute( "name", "D" );
1398
1399			// Support: IE8
1400			// Enforce case-sensitivity of name attribute
1401			if ( el.querySelectorAll( "[name=d]" ).length ) {
1402				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1403			}
1404
1405			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1406			// IE8 throws error here and will not see later tests
1407			if ( el.querySelectorAll( ":enabled" ).length !== 2 ) {
1408				rbuggyQSA.push( ":enabled", ":disabled" );
1409			}
1410
1411			// Support: IE9-11+
1412			// IE's :disabled selector does not pick up the children of disabled fieldsets
1413			docElem.appendChild( el ).disabled = true;
1414			if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
1415				rbuggyQSA.push( ":enabled", ":disabled" );
1416			}
1417
1418			// Support: Opera 10 - 11 only
1419			// Opera 10-11 does not throw on post-comma invalid pseudos
1420			el.querySelectorAll( "*,:x" );
1421			rbuggyQSA.push( ",.*:" );
1422		} );
1423	}
1424
1425	if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||
1426		docElem.webkitMatchesSelector ||
1427		docElem.mozMatchesSelector ||
1428		docElem.oMatchesSelector ||
1429		docElem.msMatchesSelector ) ) ) ) {
1430
1431		assert( function( el ) {
1432
1433			// Check to see if it's possible to do matchesSelector
1434			// on a disconnected node (IE 9)
1435			support.disconnectedMatch = matches.call( el, "*" );
1436
1437			// This should fail with an exception
1438			// Gecko does not error, returns false instead
1439			matches.call( el, "[s!='']:x" );
1440			rbuggyMatches.push( "!=", pseudos );
1441		} );
1442	}
1443
1444	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
1445	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) );
1446
1447	/* Contains
1448	---------------------------------------------------------------------- */
1449	hasCompare = rnative.test( docElem.compareDocumentPosition );
1450
1451	// Element contains another
1452	// Purposefully self-exclusive
1453	// As in, an element does not contain itself
1454	contains = hasCompare || rnative.test( docElem.contains ) ?
1455		function( a, b ) {
1456			var adown = a.nodeType === 9 ? a.documentElement : a,
1457				bup = b && b.parentNode;
1458			return a === bup || !!( bup && bup.nodeType === 1 && (
1459				adown.contains ?
1460					adown.contains( bup ) :
1461					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1462			) );
1463		} :
1464		function( a, b ) {
1465			if ( b ) {
1466				while ( ( b = b.parentNode ) ) {
1467					if ( b === a ) {
1468						return true;
1469					}
1470				}
1471			}
1472			return false;
1473		};
1474
1475	/* Sorting
1476	---------------------------------------------------------------------- */
1477
1478	// Document order sorting
1479	sortOrder = hasCompare ?
1480	function( a, b ) {
1481
1482		// Flag for duplicate removal
1483		if ( a === b ) {
1484			hasDuplicate = true;
1485			return 0;
1486		}
1487
1488		// Sort on method existence if only one input has compareDocumentPosition
1489		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1490		if ( compare ) {
1491			return compare;
1492		}
1493
1494		// Calculate position if both inputs belong to the same document

1653	// Support: IE 11+, Edge 17 - 18+
1654	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1655	// two documents; shallow comparisons work.
1656	// eslint-disable-next-line eqeqeq
1657	if ( ( elem.ownerDocument || elem ) != document ) {
1658		setDocument( elem );
1659	}
1660
1661	var fn = Expr.attrHandle[ name.toLowerCase() ],
1662
1663		// Don't get fooled by Object.prototype properties (jQuery #13807)
1664		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1665			fn( elem, name, !documentIsHTML ) :
1666			undefined;
1667
1668	return val !== undefined ?
1669		val :
1670		support.attributes || !documentIsHTML ?
1671			elem.getAttribute( name ) :
1672			( val = elem.getAttributeNode( name ) ) && val.specified ?
1673				val.value :
1674				null;
1675};
1676
1677Sizzle.escape = function( sel ) {
1678	return ( sel + "" ).replace( rcssescape, fcssescape );
1679};
1680
1681Sizzle.error = function( msg ) {
1682	throw new Error( "Syntax error, unrecognized expression: " + msg );
1683};
1684
1685/**
1686 * Document sorting and removing duplicates
1687 * @param {ArrayLike} results
1688 */
1689Sizzle.uniqueSort = function( results ) {
1690	var elem,
1691		duplicates = [],
1692		j = 0,
1693		i = 0;
1694
1695	// Unless we *know* we can detect duplicates, assume their presence
1696	hasDuplicate = !support.detectDuplicates;
1697	sortInput = !support.sortStable && results.slice( 0 );
1698	results.sort( sortOrder );
1699
1700	if ( hasDuplicate ) {
1701		while ( ( elem = results[ i++ ] ) ) {
1702			if ( elem === results[ i ] ) {
1703				j = duplicates.push( i );
1704			}
1705		}
1706		while ( j-- ) {
1707			results.splice( duplicates[ j ], 1 );
1708		}
1709	}
1710
1711	// Clear input after sorting to release objects
1712	// See https://github.com/jquery/sizzle/pull/225
1713	sortInput = null;
1714
1715	return results;
1716};
1717
1718/**
1719 * Utility function for retrieving the text value of an array of DOM nodes
1720 * @param {Array|Element} elem
1721 */
1722getText = Sizzle.getText = function( elem ) {
1723	var node,
1724		ret = "",
1725		i = 0,
1726		nodeType = elem.nodeType;
1727
1728	if ( !nodeType ) {
1729
1730		// If no nodeType, this is expected to be an array
1731		while ( ( node = elem[ i++ ] ) ) {
1732
1733			// Do not traverse comment nodes
1734			ret += getText( node );
1735		}
1736	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1737
1738		// Use textContent for elements
1739		// innerText usage removed for consistency of new lines (jQuery #11153)
1740		if ( typeof elem.textContent === "string" ) {
1741			return elem.textContent;
1742		} else {
1743
1744			// Traverse its children
1745			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1746				ret += getText( elem );
1747			}
1748		}
1749	} else if ( nodeType === 3 || nodeType === 4 ) {
1750		return elem.nodeValue;
1751	}
1752
1753	// Do not include comment or processing instruction nodes
1754
1755	return ret;
1756};
1757
1758Expr = Sizzle.selectors = {
1759
1760	// Can be adjusted by the user
1761	cacheLength: 50,
1762
1763	createPseudo: markFunction,
1764
1765	match: matchExpr,
1766
1767	attrHandle: {},
1768
1769	find: {},
1770
1771	relative: {
1772		">": { dir: "parentNode", first: true },
1773		" ": { dir: "parentNode" },
1774		"+": { dir: "previousSibling", first: true },
1775		"~": { dir: "previousSibling" }
1776	},
1777
1778	preFilter: {
1779		"ATTR": function( match ) {
1780			match[ 1 ] = match[ 1 ].replace( runescape, funescape );
1781
1782			// Move the given value to match[3] whether quoted or unquoted
1783			match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||
1784				match[ 5 ] || "" ).replace( runescape, funescape );
1785
1786			if ( match[ 2 ] === "~=" ) {
1787				match[ 3 ] = " " + match[ 3 ] + " ";
1788			}
1789
1790			return match.slice( 0, 4 );
1791		},
1792
1793		"CHILD": function( match ) {
1794
1795			/* matches from matchExpr["CHILD"]
1796				1 type (only|nth|...)
1797				2 what (child|of-type)
1798				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1799				4 xn-component of xn+y argument ([+-]?\d*n|)
1800				5 sign of xn-component
1801				6 x of xn-component
1802				7 sign of y-component
1803				8 y of y-component
1804			*/
1805			match[ 1 ] = match[ 1 ].toLowerCase();
1806
1807			if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
1808
1809				// nth-* requires argument
1810				if ( !match[ 3 ] ) {
1811					Sizzle.error( match[ 0 ] );
1812				}
1813
1814				// numeric x and y parameters for Expr.filter.CHILD
1815				// remember that false/true cast respectively to 0/1
1816				match[ 4 ] = +( match[ 4 ] ?
1817					match[ 5 ] + ( match[ 6 ] || 1 ) :
1818					2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) );
1819				match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
1820
1821				// other types prohibit arguments
1822			} else if ( match[ 3 ] ) {
1823				Sizzle.error( match[ 0 ] );
1824			}
1825
1826			return match;
1827		},
1828
1829		"PSEUDO": function( match ) {
1830			var excess,
1831				unquoted = !match[ 6 ] && match[ 2 ];
1832
1833			if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) {
1834				return null;
1835			}
1836
1837			// Accept quoted arguments as-is
1838			if ( match[ 3 ] ) {
1839				match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
1840
1841			// Strip excess characters from unquoted arguments
1842			} else if ( unquoted && rpseudo.test( unquoted ) &&
1843
1844				// Get excess from tokenize (recursively)
1845				( excess = tokenize( unquoted, true ) ) &&
1846
1847				// advance to the next closing parenthesis
1848				( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
1849
1850				// excess is a negative index
1851				match[ 0 ] = match[ 0 ].slice( 0, excess );
1852				match[ 2 ] = unquoted.slice( 0, excess );
1853			}
1854
1855			// Return only captures needed by the pseudo filter method (type and argument)
1856			return match.slice( 0, 3 );
1857		}
1858	},
1859
1860	filter: {
1861
1862		"TAG": function( nodeNameSelector ) {
1863			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1864			return nodeNameSelector === "*" ?
1865				function() {
1866					return true;
1867				} :
1868				function( elem ) {
1869					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1870				};
1871		},
1872
1873		"CLASS": function( className ) {
1874			var pattern = classCache[ className + " " ];
1875
1876			return pattern ||
1877				( pattern = new RegExp( "(^|" + whitespace +
1878					")" + className + "(" + whitespace + "|$)" ) ) && classCache(
1879						className, function( elem ) {
1880							return pattern.test(
1881								typeof elem.className === "string" && elem.className ||
1882								typeof elem.getAttribute !== "undefined" &&
1883									elem.getAttribute( "class" ) ||
1884								""
1885							);
1886				} );
1887		},
1888
1889		"ATTR": function( name, operator, check ) {
1890			return function( elem ) {
1891				var result = Sizzle.attr( elem, name );
1892
1893				if ( result == null ) {
1894					return operator === "!=";
1895				}
1896				if ( !operator ) {
1897					return true;
1898				}
1899
1900				result += "";
1901
1902				/* eslint-disable max-len */
1903
1904				return operator === "=" ? result === check :
1905					operator === "!=" ? result !== check :
1906					operator === "^=" ? check && result.indexOf( check ) === 0 :
1907					operator === "*=" ? check && result.indexOf( check ) > -1 :
1908					operator === "$=" ? check && result.slice( -check.length ) === check :
1909					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1910					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1911					false;
1912				/* eslint-enable max-len */
1913
1914			};
1915		},
1916
1917		"CHILD": function( type, what, _argument, first, last ) {
1918			var simple = type.slice( 0, 3 ) !== "nth",
1919				forward = type.slice( -4 ) !== "last",
1920				ofType = what === "of-type";
1921
1922			return first === 1 && last === 0 ?
1923
1924				// Shortcut for :nth-*(n)
1925				function( elem ) {
1926					return !!elem.parentNode;
1927				} :
1928
1929				function( elem, _context, xml ) {
1930					var cache, uniqueCache, outerCache, node, nodeIndex, start,
1931						dir = simple !== forward ? "nextSibling" : "previousSibling",
1932						parent = elem.parentNode,
1933						name = ofType && elem.nodeName.toLowerCase(),
1934						useCache = !xml && !ofType,
1935						diff = false;
1936
1937					if ( parent ) {
1938
1939						// :(first|last|only)-(child|of-type)
1940						if ( simple ) {
1941							while ( dir ) {
1942								node = elem;
1943								while ( ( node = node[ dir ] ) ) {
1944									if ( ofType ?
1945										node.nodeName.toLowerCase() === name :
1946										node.nodeType === 1 ) {
1947
1948										return false;
1949									}
1950								}
1951
1952								// Reverse direction for :only-* (if we haven't yet done so)
1953								start = dir = type === "only" && !start && "nextSibling";
1954							}
1955							return true;
1956						}
1957
1958						start = [ forward ? parent.firstChild : parent.lastChild ];
1959
1960						// non-xml :nth-child(...) stores cache data on `parent`
1961						if ( forward && useCache ) {
1962
1963							// Seek `elem` from a previously-cached index
1964
1965							// ...in a gzip-friendly way
1966							node = parent;
1967							outerCache = node[ expando ] || ( node[ expando ] = {} );
1968
1969							// Support: IE <9 only
1970							// Defend against cloned attroperties (jQuery gh-1709)
1971							uniqueCache = outerCache[ node.uniqueID ] ||
1972								( outerCache[ node.uniqueID ] = {} );
1973
1974							cache = uniqueCache[ type ] || [];
1975							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1976							diff = nodeIndex && cache[ 2 ];
1977							node = nodeIndex && parent.childNodes[ nodeIndex ];
1978
1979							while ( ( node = ++nodeIndex && node && node[ dir ] ||
1980
1981								// Fallback to seeking `elem` from the start
1982								( diff = nodeIndex = 0 ) || start.pop() ) ) {
1983
1984								// When found, cache indexes on `parent` and break
1985								if ( node.nodeType === 1 && ++diff && node === elem ) {
1986									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1987									break;
1988								}
1989							}
1990
1991						} else {
1992
1993							// Use previously-cached element index if available
1994							if ( useCache ) {
1995
1996								// ...in a gzip-friendly way
1997								node = elem;
1998								outerCache = node[ expando ] || ( node[ expando ] = {} );
1999
2000								// Support: IE <9 only
2001								// Defend against cloned attroperties (jQuery gh-1709)
2002								uniqueCache = outerCache[ node.uniqueID ] ||
2003									( outerCache[ node.uniqueID ] = {} );
2004
2005								cache = uniqueCache[ type ] || [];
2006								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
2007								diff = nodeIndex;
2008							}
2009
2010							// xml :nth-child(...)
2011							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
2012							if ( diff === false ) {
2013
2014								// Use the same loop as above to seek `elem` from the start
2015								while ( ( node = ++nodeIndex && node && node[ dir ] ||
2016									( diff = nodeIndex = 0 ) || start.pop() ) ) {
2017
2018									if ( ( ofType ?
2019										node.nodeName.toLowerCase() === name :
2020										node.nodeType === 1 ) &&
2021										++diff ) {
2022
2023										// Cache the index of each encountered element
2024										if ( useCache ) {
2025											outerCache = node[ expando ] ||
2026												( node[ expando ] = {} );
2027
2028											// Support: IE <9 only
2029											// Defend against cloned attroperties (jQuery gh-1709)
2030											uniqueCache = outerCache[ node.uniqueID ] ||
2031												( outerCache[ node.uniqueID ] = {} );
2032
2033											uniqueCache[ type ] = [ dirruns, diff ];
2034										}
2035
2036										if ( node === elem ) {
2037											break;
2038										}
2039									}
2040								}
2041							}
2042						}
2043
2044						// Incorporate the offset, then check against cycle size
2045						diff -= last;
2046						return diff === first || ( diff % first === 0 && diff / first >= 0 );
2047					}
2048				};
2049		},
2050
2051		"PSEUDO": function( pseudo, argument ) {
2052
2053			// pseudo-class names are case-insensitive
2054			// http://www.w3.org/TR/selectors/#pseudo-classes
2055			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2056			// Remember that setFilters inherits from pseudos
2057			var args,
2058				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2059					Sizzle.error( "unsupported pseudo: " + pseudo );
2060
2061			// The user may use createPseudo to indicate that
2062			// arguments are needed to create the filter function
2063			// just as Sizzle does
2064			if ( fn[ expando ] ) {
2065				return fn( argument );
2066			}
2067
2068			// But maintain support for old signatures
2069			if ( fn.length > 1 ) {
2070				args = [ pseudo, pseudo, "", argument ];
2071				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2072					markFunction( function( seed, matches ) {
2073						var idx,
2074							matched = fn( seed, argument ),
2075							i = matched.length;
2076						while ( i-- ) {
2077							idx = indexOf( seed, matched[ i ] );
2078							seed[ idx ] = !( matches[ idx ] = matched[ i ] );
2079						}
2080					} ) :
2081					function( elem ) {
2082						return fn( elem, 0, args );
2083					};
2084			}
2085
2086			return fn;
2087		}
2088	},
2089
2090	pseudos: {
2091
2092		// Potentially complex pseudos
2093		"not": markFunction( function( selector ) {
2094
2095			// Trim the selector passed to compile
2096			// to avoid treating leading and trailing
2097			// spaces as combinators
2098			var input = [],
2099				results = [],
2100				matcher = compile( selector.replace( rtrim, "$1" ) );
2101
2102			return matcher[ expando ] ?
2103				markFunction( function( seed, matches, _context, xml ) {
2104					var elem,
2105						unmatched = matcher( seed, null, xml, [] ),
2106						i = seed.length;
2107
2108					// Match elements unmatched by `matcher`
2109					while ( i-- ) {
2110						if ( ( elem = unmatched[ i ] ) ) {
2111							seed[ i ] = !( matches[ i ] = elem );
2112						}
2113					}
2114				} ) :
2115				function( elem, _context, xml ) {
2116					input[ 0 ] = elem;
2117					matcher( input, null, xml, results );
2118
2119					// Don't keep the element (issue #299)
2120					input[ 0 ] = null;
2121					return !results.pop();
2122				};
2123		} ),
2124
2125		"has": markFunction( function( selector ) {
2126			return function( elem ) {
2127				return Sizzle( selector, elem ).length > 0;
2128			};
2129		} ),
2130
2131		"contains": markFunction( function( text ) {
2132			text = text.replace( runescape, funescape );
2133			return function( elem ) {
2134				return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
2135			};
2136		} ),
2137
2138		// "Whether an element is represented by a :lang() selector
2139		// is based solely on the element's language value
2140		// being equal to the identifier C,
2141		// or beginning with the identifier C immediately followed by "-".
2142		// The matching of C against the element's language value is performed case-insensitively.
2143		// The identifier C does not have to be a valid language name."
2144		// http://www.w3.org/TR/selectors/#lang-pseudo
2145		"lang": markFunction( function( lang ) {
2146
2147			// lang value must be a valid identifier
2148			if ( !ridentifier.test( lang || "" ) ) {
2149				Sizzle.error( "unsupported lang: " + lang );
2150			}
2151			lang = lang.replace( runescape, funescape ).toLowerCase();
2152			return function( elem ) {
2153				var elemLang;
2154				do {
2155					if ( ( elemLang = documentIsHTML ?
2156						elem.lang :
2157						elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
2158
2159						elemLang = elemLang.toLowerCase();
2160						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2161					}
2162				} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
2163				return false;
2164			};
2165		} ),
2166
2167		// Miscellaneous
2168		"target": function( elem ) {
2169			var hash = window.location && window.location.hash;
2170			return hash && hash.slice( 1 ) === elem.id;
2171		},
2172
2173		"root": function( elem ) {
2174			return elem === docElem;
2175		},
2176
2177		"focus": function( elem ) {
2178			return elem === document.activeElement &&
2179				( !document.hasFocus || document.hasFocus() ) &&
2180				!!( elem.type || elem.href || ~elem.tabIndex );
2181		},
2182
2183		// Boolean properties
2184		"enabled": createDisabledPseudo( false ),
2185		"disabled": createDisabledPseudo( true ),
2186
2187		"checked": function( elem ) {
2188
2189			// In CSS3, :checked should return both checked and selected elements
2190			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2191			var nodeName = elem.nodeName.toLowerCase();
2192			return ( nodeName === "input" && !!elem.checked ) ||
2193				( nodeName === "option" && !!elem.selected );
2194		},
2195
2196		"selected": function( elem ) {
2197
2198			// Accessing this property makes selected-by-default
2199			// options in Safari work properly
2200			if ( elem.parentNode ) {
2201				// eslint-disable-next-line no-unused-expressions
2202				elem.parentNode.selectedIndex;
2203			}
2204
2205			return elem.selected === true;
2206		},
2207
2208		// Contents
2209		"empty": function( elem ) {
2210
2211			// http://www.w3.org/TR/selectors/#empty-pseudo
2212			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2213			//   but not by others (comment: 8; processing instruction: 7; etc.)
2214			// nodeType < 6 works because attributes (2) do not appear as children
2215			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2216				if ( elem.nodeType < 6 ) {
2217					return false;
2218				}
2219			}
2220			return true;
2221		},
2222
2223		"parent": function( elem ) {
2224			return !Expr.pseudos[ "empty" ]( elem );
2225		},
2226
2227		// Element/input types
2228		"header": function( elem ) {
2229			return rheader.test( elem.nodeName );
2230		},
2231
2232		"input": function( elem ) {
2233			return rinputs.test( elem.nodeName );
2234		},
2235
2236		"button": function( elem ) {
2237			var name = elem.nodeName.toLowerCase();
2238			return name === "input" && elem.type === "button" || name === "button";
2239		},
2240
2241		"text": function( elem ) {
2242			var attr;
2243			return elem.nodeName.toLowerCase() === "input" &&
2244				elem.type === "text" &&
2245

2246				// Support: IE<8
2247				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2248				( ( attr = elem.getAttribute( "type" ) ) == null ||
2249					attr.toLowerCase() === "text" );
2250		},
2251
2252		// Position-in-collection
2253		"first": createPositionalPseudo( function() {
2254			return [ 0 ];
2255		} ),
2256
2257		"last": createPositionalPseudo( function( _matchIndexes, length ) {
2258			return [ length - 1 ];
2259		} ),
2260
2261		"eq": createPositionalPseudo( function( _matchIndexes, length, argument ) {
2262			return [ argument < 0 ? argument + length : argument ];
2263		} ),
2264
2265		"even": createPositionalPseudo( function( matchIndexes, length ) {
2266			var i = 0;
2267			for ( ; i < length; i += 2 ) {
2268				matchIndexes.push( i );
2269			}
2270			return matchIndexes;
2271		} ),
2272
2273		"odd": createPositionalPseudo( function( matchIndexes, length ) {
2274			var i = 1;
2275			for ( ; i < length; i += 2 ) {
2276				matchIndexes.push( i );
2277			}
2278			return matchIndexes;
2279		} ),
2280
2281		"lt": createPositionalPseudo( function( matchIndexes, length, argument ) {
2282			var i = argument < 0 ?
2283				argument + length :
2284				argument > length ?
2285					length :
2286					argument;
2287			for ( ; --i >= 0; ) {
2288				matchIndexes.push( i );
2289			}
2290			return matchIndexes;
2291		} ),
2292
2293		"gt": createPositionalPseudo( function( matchIndexes, length, argument ) {
2294			var i = argument < 0 ? argument + length : argument;
2295			for ( ; ++i < length; ) {
2296				matchIndexes.push( i );
2297			}
2298			return matchIndexes;
2299		} )
2300	}
2301};
2302
2303Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ];
2304
2305// Add button/input type pseudos
2306for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2307	Expr.pseudos[ i ] = createInputPseudo( i );
2308}
2309for ( i in { submit: true, reset: true } ) {
2310	Expr.pseudos[ i ] = createButtonPseudo( i );
2311}
2312
2313// Easy API for creating new setFilters
2314function setFilters() {}
2315setFilters.prototype = Expr.filters = Expr.pseudos;
2316Expr.setFilters = new setFilters();
2317
2318tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2319	var matched, match, tokens, type,
2320		soFar, groups, preFilters,
2321		cached = tokenCache[ selector + " " ];
2322
2323	if ( cached ) {
2324		return parseOnly ? 0 : cached.slice( 0 );
2325	}
2326
2327	soFar = selector;
2328	groups = [];
2329	preFilters = Expr.preFilter;
2330
2331	while ( soFar ) {
2332
2333		// Comma and first run
2334		if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
2335			if ( match ) {
2336
2337				// Don't consume trailing commas as valid
2338				soFar = soFar.slice( match[ 0 ].length ) || soFar;
2339			}
2340			groups.push( ( tokens = [] ) );
2341		}
2342
2343		matched = false;
2344
2345		// Combinators
2346		if ( ( match = rcombinators.exec( soFar ) ) ) {
2347			matched = match.shift();
2348			tokens.push( {
2349				value: matched,
2350
2351				// Cast descendant combinators to space
2352				type: match[ 0 ].replace( rtrim, " " )
2353			} );
2354			soFar = soFar.slice( matched.length );
2355		}
2356
2357		// Filters
2358		for ( type in Expr.filter ) {
2359			if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
2360				( match = preFilters[ type ]( match ) ) ) ) {
2361				matched = match.shift();
2362				tokens.push( {
2363					value: matched,
2364					type: type,
2365					matches: match
2366				} );
2367				soFar = soFar.slice( matched.length );
2368			}
2369		}
2370
2371		if ( !matched ) {
2372			break;
2373		}
2374	}
2375
2376	// Return the length of the invalid excess
2377	// if we're just parsing
2378	// Otherwise, throw an error or return tokens
2379	return parseOnly ?
2380		soFar.length :
2381		soFar ?
2382			Sizzle.error( selector ) :
2383
2384			// Cache the tokens
2385			tokenCache( selector, groups ).slice( 0 );
2386};
2387
2388function toSelector( tokens ) {
2389	var i = 0,
2390		len = tokens.length,
2391		selector = "";
2392	for ( ; i < len; i++ ) {
2393		selector += tokens[ i ].value;
2394	}
2395	return selector;
2396}
2397
2398function addCombinator( matcher, combinator, base ) {
2399	var dir = combinator.dir,
2400		skip = combinator.next,
2401		key = skip || dir,
2402		checkNonElements = base && key === "parentNode",
2403		doneName = done++;
2404
2405	return combinator.first ?
2406
2407		// Check against closest ancestor/preceding element
2408		function( elem, context, xml ) {
2409			while ( ( elem = elem[ dir ] ) ) {
2410				if ( elem.nodeType === 1 || checkNonElements ) {
2411					return matcher( elem, context, xml );
2412				}
2413			}
2414			return false;
2415		} :
2416
2417		// Check against all ancestor/preceding elements
2418		function( elem, context, xml ) {
2419			var oldCache, uniqueCache, outerCache,
2420				newCache = [ dirruns, doneName ];
2421
2422			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2423			if ( xml ) {
2424				while ( ( elem = elem[ dir ] ) ) {
2425					if ( elem.nodeType === 1 || checkNonElements ) {
2426						if ( matcher( elem, context, xml ) ) {
2427							return true;
2428						}
2429					}
2430				}
2431			} else {
2432				while ( ( elem = elem[ dir ] ) ) {
2433					if ( elem.nodeType === 1 || checkNonElements ) {
2434						outerCache = elem[ expando ] || ( elem[ expando ] = {} );
2435
2436						// Support: IE <9 only
2437						// Defend against cloned attroperties (jQuery gh-1709)
2438						uniqueCache = outerCache[ elem.uniqueID ] ||
2439							( outerCache[ elem.uniqueID ] = {} );
2440
2441						if ( skip && skip === elem.nodeName.toLowerCase() ) {
2442							elem = elem[ dir ] || elem;
2443						} else if ( ( oldCache = uniqueCache[ key ] ) &&
2444							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2445
2446							// Assign to newCache so results back-propagate to previous elements
2447							return ( newCache[ 2 ] = oldCache[ 2 ] );
2448						} else {
2449
2450							// Reuse newcache so results back-propagate to previous elements
2451							uniqueCache[ key ] = newCache;
2452
2453							// A match means we're done; a fail means we have to keep checking
2454							if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
2455								return true;
2456							}
2457						}
2458					}
2459				}
2460			}
2461			return false;
2462		};
2463}
2464
2465function elementMatcher( matchers ) {
2466	return matchers.length > 1 ?
2467		function( elem, context, xml ) {
2468			var i = matchers.length;
2469			while ( i-- ) {
2470				if ( !matchers[ i ]( elem, context, xml ) ) {
2471					return false;
2472				}
2473			}
2474			return true;
2475		} :
2476		matchers[ 0 ];
2477}
2478
2479function multipleContexts( selector, contexts, results ) {
2480	var i = 0,
2481		len = contexts.length;
2482	for ( ; i < len; i++ ) {
2483		Sizzle( selector, contexts[ i ], results );
2484	}
2485	return results;
2486}
2487
2488function condense( unmatched, map, filter, context, xml ) {
2489	var elem,
2490		newUnmatched = [],
2491		i = 0,
2492		len = unmatched.length,
2493		mapped = map != null;
2494
2495	for ( ; i < len; i++ ) {
2496		if ( ( elem = unmatched[ i ] ) ) {
2497			if ( !filter || filter( elem, context, xml ) ) {
2498				newUnmatched.push( elem );
2499				if ( mapped ) {
2500					map.push( i );
2501				}
2502			}
2503		}
2504	}
2505
2506	return newUnmatched;
2507}
2508
2509function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2510	if ( postFilter && !postFilter[ expando ] ) {
2511		postFilter = setMatcher( postFilter );
2512	}
2513	if ( postFinder && !postFinder[ expando ] ) {
2514		postFinder = setMatcher( postFinder, postSelector );
2515	}
2516	return markFunction( function( seed, results, context, xml ) {
2517		var temp, i, elem,
2518			preMap = [],
2519			postMap = [],
2520			preexisting = results.length,
2521
2522			// Get initial elements from seed or context
2523			elems = seed || multipleContexts(
2524				selector || "*",
2525				context.nodeType ? [ context ] : context,
2526				[]
2527			),
2528
2529			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2530			matcherIn = preFilter && ( seed || !selector ) ?
2531				condense( elems, preMap, preFilter, context, xml ) :
2532				elems,
2533
2534			matcherOut = matcher ?
2535
2536				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2537				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2538
2539					// ...intermediate processing is necessary
2540					[] :
2541
2542					// ...otherwise use results directly
2543					results :
2544				matcherIn;
2545
2546		// Find primary matches
2547		if ( matcher ) {
2548			matcher( matcherIn, matcherOut, context, xml );
2549		}
2550
2551		// Apply postFilter
2552		if ( postFilter ) {
2553			temp = condense( matcherOut, postMap );
2554			postFilter( temp, [], context, xml );
2555
2556			// Un-match failing elements by moving them back to matcherIn
2557			i = temp.length;
2558			while ( i-- ) {
2559				if ( ( elem = temp[ i ] ) ) {
2560					matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
2561				}
2562			}
2563		}
2564
2565		if ( seed ) {
2566			if ( postFinder || preFilter ) {
2567				if ( postFinder ) {
2568
2569					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2570					temp = [];
2571					i = matcherOut.length;
2572					while ( i-- ) {
2573						if ( ( elem = matcherOut[ i ] ) ) {
2574
2575							// Restore matcherIn since elem is not yet a final match
2576							temp.push( ( matcherIn[ i ] = elem ) );
2577						}
2578					}
2579					postFinder( null, ( matcherOut = [] ), temp, xml );
2580				}
2581
2582				// Move matched elements from seed to results to keep them synchronized
2583				i = matcherOut.length;
2584				while ( i-- ) {
2585					if ( ( elem = matcherOut[ i ] ) &&
2586						( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {
2587
2588						seed[ temp ] = !( results[ temp ] = elem );
2589					}
2590				}
2591			}
2592
2593		// Add elements to results, through postFinder if defined
2594		} else {
2595			matcherOut = condense(
2596				matcherOut === results ?
2597					matcherOut.splice( preexisting, matcherOut.length ) :
2598					matcherOut
2599			);
2600			if ( postFinder ) {
2601				postFinder( null, results, matcherOut, xml );
2602			} else {
2603				push.apply( results, matcherOut );
2604			}
2605		}
2606	} );
2607}
2608
2609function matcherFromTokens( tokens ) {
2610	var checkContext, matcher, j,
2611		len = tokens.length,
2612		leadingRelative = Expr.relative[ tokens[ 0 ].type ],
2613		implicitRelative = leadingRelative || Expr.relative[ " " ],
2614		i = leadingRelative ? 1 : 0,
2615
2616		// The foundational matcher ensures that elements are reachable from top-level context(s)
2617		matchContext = addCombinator( function( elem ) {
2618			return elem === checkContext;
2619		}, implicitRelative, true ),
2620		matchAnyContext = addCombinator( function( elem ) {
2621			return indexOf( checkContext, elem ) > -1;
2622		}, implicitRelative, true ),
2623		matchers = [ function( elem, context, xml ) {
2624			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2625				( checkContext = context ).nodeType ?
2626					matchContext( elem, context, xml ) :
2627					matchAnyContext( elem, context, xml ) );
2628
2629			// Avoid hanging onto element (issue #299)
2630			checkContext = null;
2631			return ret;
2632		} ];
2633
2634	for ( ; i < len; i++ ) {
2635		if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
2636			matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
2637		} else {
2638			matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
2639
2640			// Return special upon seeing a positional matcher
2641			if ( matcher[ expando ] ) {
2642
2643				// Find the next relative operator (if any) for proper handling
2644				j = ++i;
2645				for ( ; j < len; j++ ) {
2646					if ( Expr.relative[ tokens[ j ].type ] ) {
2647						break;
2648					}
2649				}
2650				return setMatcher(
2651					i > 1 && elementMatcher( matchers ),
2652					i > 1 && toSelector(
2653
2654					// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2655					tokens
2656						.slice( 0, i - 1 )
2657						.concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
2658					).replace( rtrim, "$1" ),
2659					matcher,
2660					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2661					j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
2662					j < len && toSelector( tokens )
2663				);
2664			}
2665			matchers.push( matcher );
2666		}
2667	}
2668
2669	return elementMatcher( matchers );
2670}
2671
2672function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2673	var bySet = setMatchers.length > 0,
2674		byElement = elementMatchers.length > 0,
2675		superMatcher = function( seed, context, xml, results, outermost ) {
2676			var elem, j, matcher,
2677				matchedCount = 0,
2678				i = "0",
2679				unmatched = seed && [],
2680				setMatched = [],
2681				contextBackup = outermostContext,
2682
2683				// We must always have either seed elements or outermost context
2684				elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ),
2685
2686				// Use integer dirruns iff this is the outermost matcher
2687				dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
2688				len = elems.length;
2689
2690			if ( outermost ) {
2691
2692				// Support: IE 11+, Edge 17 - 18+
2693				// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2694				// two documents; shallow comparisons work.
2695				// eslint-disable-next-line eqeqeq
2696				outermostContext = context == document || context || outermost;
2697			}
2698
2699			// Add elements passing elementMatchers directly to results
2700			// Support: IE<9, Safari
2701			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2702			for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
2703				if ( byElement && elem ) {
2704					j = 0;
2705
2706					// Support: IE 11+, Edge 17 - 18+
2707					// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2708					// two documents; shallow comparisons work.
2709					// eslint-disable-next-line eqeqeq
2710					if ( !context && elem.ownerDocument != document ) {
2711						setDocument( elem );
2712						xml = !documentIsHTML;
2713					}
2714					while ( ( matcher = elementMatchers[ j++ ] ) ) {
2715						if ( matcher( elem, context || document, xml ) ) {
2716							results.push( elem );
2717							break;
2718						}
2719					}
2720					if ( outermost ) {
2721						dirruns = dirrunsUnique;
2722					}
2723				}
2724
2725				// Track unmatched elements for set filters
2726				if ( bySet ) {
2727
2728					// They will have gone through all possible matchers
2729					if ( ( elem = !matcher && elem ) ) {
2730						matchedCount--;
2731					}
2732
2733					// Lengthen the array for every element, matched or not
2734					if ( seed ) {
2735						unmatched.push( elem );
2736					}
2737				}
2738			}
2739
2740			// `i` is now the count of elements visited above, and adding it to `matchedCount`
2741			// makes the latter nonnegative.
2742			matchedCount += i;
2743
2744			// Apply set filters to unmatched elements
2745			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2746			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2747			// no element matchers and no seed.
2748			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2749			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2750			// numerically zero.
2751			if ( bySet && i !== matchedCount ) {
2752				j = 0;
2753				while ( ( matcher = setMatchers[ j++ ] ) ) {
2754					matcher( unmatched, setMatched, context, xml );
2755				}
2756
2757				if ( seed ) {
2758
2759					// Reintegrate element matches to eliminate the need for sorting
2760					if ( matchedCount > 0 ) {
2761						while ( i-- ) {
2762							if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
2763								setMatched[ i ] = pop.call( results );
2764							}
2765						}
2766					}
2767
2768					// Discard index placeholder values to get only actual matches
2769					setMatched = condense( setMatched );
2770				}
2771
2772				// Add matches to results
2773				push.apply( results, setMatched );
2774
2775				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2776				if ( outermost && !seed && setMatched.length > 0 &&
2777					( matchedCount + setMatchers.length ) > 1 ) {
2778
2779					Sizzle.uniqueSort( results );
2780				}
2781			}
2782
2783			// Override manipulation of globals by nested matchers
2784			if ( outermost ) {
2785				dirruns = dirrunsUnique;
2786				outermostContext = contextBackup;
2787			}
2788
2789			return unmatched;
2790		};
2791
2792	return bySet ?
2793		markFunction( superMatcher ) :
2794		superMatcher;
2795}
2796
2797compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2798	var i,
2799		setMatchers = [],
2800		elementMatchers = [],
2801		cached = compilerCache[ selector + " " ];
2802
2803	if ( !cached ) {
2804
2805		// Generate a function of recursive functions that can be used to check each element
2806		if ( !match ) {
2807			match = tokenize( selector );
2808		}
2809		i = match.length;
2810		while ( i-- ) {
2811			cached = matcherFromTokens( match[ i ] );
2812			if ( cached[ expando ] ) {
2813				setMatchers.push( cached );
2814			} else {
2815				elementMatchers.push( cached );
2816			}
2817		}
2818
2819		// Cache the compiled function
2820		cached = compilerCache(
2821			selector,
2822			matcherFromGroupMatchers( elementMatchers, setMatchers )
2823		);
2824
2825		// Save selector and tokenization
2826		cached.selector = selector;
2827	}
2828	return cached;
2829};
2830
2831/**
2832 * A low-level selection function that works with Sizzle's compiled
2833 *  selector functions
2834 * @param {String|Function} selector A selector or a pre-compiled
2835 *  selector function built with Sizzle.compile
2836 * @param {Element} context
2837 * @param {Array} [results]
2838 * @param {Array} [seed] A set of elements to match against
2839 */
2840select = Sizzle.select = function( selector, context, results, seed ) {
2841	var i, tokens, token, type, find,
2842		compiled = typeof selector === "function" && selector,
2843		match = !seed && tokenize( ( selector = compiled.selector || selector ) );
2844
2845	results = results || [];
2846
2847	// Try to minimize operations if there is only one selector in the list and no seed
2848	// (the latter of which guarantees us context)
2849	if ( match.length === 1 ) {
2850
2851		// Reduce context if the leading compound selector is an ID
2852		tokens = match[ 0 ] = match[ 0 ].slice( 0 );
2853		if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
2854			context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
2855
2856			context = ( Expr.find[ "ID" ]( token.matches[ 0 ]
2857				.replace( runescape, funescape ), context ) || [] )[ 0 ];
2858			if ( !context ) {
2859				return results;
2860
2861			// Precompiled matchers will still verify ancestry, so step up a level
2862			} else if ( compiled ) {
2863				context = context.parentNode;
2864			}
2865
2866			selector = selector.slice( tokens.shift().value.length );
2867		}
2868
2869		// Fetch a seed set for right-to-left matching
2870		i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length;
2871		while ( i-- ) {
2872			token = tokens[ i ];
2873
2874			// Abort if we hit a combinator
2875			if ( Expr.relative[ ( type = token.type ) ] ) {
2876				break;
2877			}
2878			if ( ( find = Expr.find[ type ] ) ) {
2879
2880				// Search, expanding context for leading sibling combinators
2881				if ( ( seed = find(
2882					token.matches[ 0 ].replace( runescape, funescape ),
2883					rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||
2884						context
2885				) ) ) {
2886
2887					// If seed is empty or no tokens remain, we can return early
2888					tokens.splice( i, 1 );
2889					selector = seed.length && toSelector( tokens );
2890					if ( !selector ) {
2891						push.apply( results, seed );
2892						return results;
2893					}
2894
2895					break;
2896				}
2897			}
2898		}
2899	}
2900
2901	// Compile and execute a filtering function if one is not provided
2902	// Provide `match` to avoid retokenization if we modified the selector above
2903	( compiled || compile( selector, match ) )(
2904		seed,
2905		context,
2906		!documentIsHTML,
2907		results,
2908		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2909	);
2910	return results;
2911};
2912
2913// One-time assignments
2914
2915// Sort stability
2916support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
2917
2918// Support: Chrome 14-35+
2919// Always assume duplicates if they aren't passed to the comparison function
2920support.detectDuplicates = !!hasDuplicate;
2921
2922// Initialize against the default document
2923setDocument();
2924
2925// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2926// Detached nodes confoundingly follow *each other*
2927support.sortDetached = assert( function( el ) {
2928
2929	// Should return 1, but returns 4 (following)
2930	return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
2931} );
2932
2933// Support: IE<8
2934// Prevent attribute/property "interpolation"
2935// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2936if ( !assert( function( el ) {
2937	el.innerHTML = "<a href='#'></a>";
2938	return el.firstChild.getAttribute( "href" ) === "#";
2939} ) ) {
2940	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2941		if ( !isXML ) {
2942			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2943		}
2944	} );
2945}
2946
2947// Support: IE<9
2948// Use defaultValue in place of getAttribute("value")
2949if ( !support.attributes || !assert( function( el ) {
2950	el.innerHTML = "<input/>";
2951	el.firstChild.setAttribute( "value", "" );
2952	return el.firstChild.getAttribute( "value" ) === "";
2953} ) ) {
2954	addHandle( "value", function( elem, _name, isXML ) {
2955		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2956			return elem.defaultValue;
2957		}
2958	} );
2959}
2960
2961// Support: IE<9
2962// Use getAttributeNode to fetch booleans when getAttribute lies
2963if ( !assert( function( el ) {
2964	return el.getAttribute( "disabled" ) == null;
2965} ) ) {
2966	addHandle( booleans, function( elem, name, isXML ) {
2967		var val;
2968		if ( !isXML ) {
2969			return elem[ name ] === true ? name.toLowerCase() :
2970				( val = elem.getAttributeNode( name ) ) && val.specified ?
2971					val.value :
2972					null;
2973		}
2974	} );
2975}
2976
2977return Sizzle;
2978
2979} )( window );
2980
2981
2982
2983jQuery.find = Sizzle;
2984jQuery.expr = Sizzle.selectors;
2985
2986// Deprecated
2987jQuery.expr[ ":" ] = jQuery.expr.pseudos;
2988jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2989jQuery.text = Sizzle.getText;
2990jQuery.isXMLDoc = Sizzle.isXML;
2991jQuery.contains = Sizzle.contains;
2992jQuery.escapeSelector = Sizzle.escape;
2993
2994
2995
2996
2997var dir = function( elem, dir, until ) {
2998	var matched = [],
2999		truncate = until !== undefined;
3000
3001	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
3002		if ( elem.nodeType === 1 ) {
3003			if ( truncate && jQuery( elem ).is( until ) ) {
3004				break;
3005			}
3006			matched.push( elem );
3007		}
3008	}
3009	return matched;
3010};
3011
3012
3013var siblings = function( n, elem ) {
3014	var matched = [];
3015
3016	for ( ; n; n = n.nextSibling ) {
3017		if ( n.nodeType === 1 && n !== elem ) {
3018			matched.push( n );
3019		}
3020	}
3021
3022	return matched;
3023};
3024
3025
3026var rneedsContext = jQuery.expr.match.needsContext;
3027
3028
3029
3030function nodeName( elem, name ) {
3031
3032	return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
3033
3034}