https://massculturalcouncil.org/wp-content/themes/wpx/assets/js/libraries.js

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

466					ret.push( value );
467				}
468			}
469
470		// Go through every key on the object,
471		} else {
472			for ( i in elems ) {
473				value = callback( elems[ i ], i, arg );
474
475				if ( value != null ) {
476					ret.push( value );
477				}
478			}
479		}
480
481		// Flatten any nested arrays
482		return flat( ret );
483	},
484
485	// A global GUID counter for objects
486	guid: 1,
487
488	// jQuery.support is not used in Core but other projects attach their
489	// properties to it so it needs to exist.
490	support: support
491} );
492
493if ( typeof Symbol === "function" ) {
494	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
495}
496
497// Populate the class2type map
498jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
499function( _i, name ) {
500	class2type[ "[object " + name + "]" ] = name.toLowerCase();
501} );
502
503function isArrayLike( obj ) {
504
505	// Support: real iOS 8.2 only (not reproducible in simulator)
506	// `in` check used to prevent JIT error (gh-2145)
507	// hasOwn isn't used here due to false negatives
508	// regarding Nodelist length in IE
509	var length = !!obj && "length" in obj && obj.length,
510		type = toType( obj );
511
512	if ( isFunction( obj ) || isWindow( obj ) ) {
513		return false;
514	}
515
516	return type === "array" || length === 0 ||
517		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
518}
519var Sizzle =
520/*!
521 * Sizzle CSS Selector Engine v2.3.5
522 * https://sizzlejs.com/
523 *
524 * Copyright JS Foundation and other contributors
525 * Released under the MIT license
526 * https://js.foundation/
527 *
528 * Date: 2020-03-14
529 */
530( function( window ) {
531var i,
532	support,
533	Expr,
534	getText,
535	isXML,
536	tokenize,
537	compile,
538	select,
539	outermostContext,
540	sortInput,
541	hasDuplicate,
542
543	// Local document vars
544	setDocument,
545	document,
546	docElem,
547	documentIsHTML,
548	rbuggyQSA,
549	rbuggyMatches,
550	matches,
551	contains,
552
553	// Instance-specific data
554	expando = "sizzle" + 1 * new Date(),
555	preferredDoc = window.document,
556	dirruns = 0,
557	done = 0,
558	classCache = createCache(),
559	tokenCache = createCache(),
560	compilerCache = createCache(),
561	nonnativeSelectorCache = createCache(),
562	sortOrder = function( a, b ) {
563		if ( a === b ) {
564			hasDuplicate = true;
565		}
566		return 0;
567	},
568
569	// Instance methods
570	hasOwn = ( {} ).hasOwnProperty,
571	arr = [],
572	pop = arr.pop,
573	pushNative = arr.push,
574	push = arr.push,
575	slice = arr.slice,
576
577	// Use a stripped-down indexOf as it's faster than native
578	// https://jsperf.com/thor-indexof-vs-for/5
579	indexOf = function( list, elem ) {
580		var i = 0,
581			len = list.length;
582		for ( ; i < len; i++ ) {
583			if ( list[ i ] === elem ) {
584				return i;
585			}
586		}
587		return -1;
588	},
589
590	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
591		"ismap|loop|multiple|open|readonly|required|scoped",
592
593	// Regular expressions
594
595	// http://www.w3.org/TR/css3-selectors/#whitespace
596	whitespace = "[\\x20\\t\\r\\n\\f]",
597
598	// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
599	identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
600		"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
601
602	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
603	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
604
605		// Operator (capture 2)
606		"*([*^$|!~]?=)" + whitespace +
607
608		// "Attribute values must be CSS identifiers [capture 5]
609		// or strings [capture 3 or capture 4]"
610		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
611		whitespace + "*\\]",
612
613	pseudos = ":(" + identifier + ")(?:\\((" +
614
615		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
616		// 1. quoted (capture 3; capture 4 or capture 5)
617		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
618
619		// 2. simple (capture 6)
620		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
621
622		// 3. anything else (capture 2)
623		".*" +
624		")\\)|)",
625
626	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
627	rwhitespace = new RegExp( whitespace + "+", "g" ),
628	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
629		whitespace + "+$", "g" ),
630
631	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
632	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
633		"*" ),
634	rdescend = new RegExp( whitespace + "|>" ),
635
636	rpseudo = new RegExp( pseudos ),
637	ridentifier = new RegExp( "^" + identifier + "$" ),
638
639	matchExpr = {
640		"ID": new RegExp( "^#(" + identifier + ")" ),
641		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
642		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
643		"ATTR": new RegExp( "^" + attributes ),
644		"PSEUDO": new RegExp( "^" + pseudos ),
645		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
646			whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
647			whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
648		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
649
650		// For use in libraries implementing .is()
651		// We use this for POS matching in `select`
652		"needsContext": new RegExp( "^" + whitespace +
653			"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
654			"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
655	},
656
657	rhtml = /HTML$/i,
658	rinputs = /^(?:input|select|textarea|button)$/i,
659	rheader = /^h\d$/i,
660
661	rnative = /^[^{]+\{\s*\[native \w/,
662
663	// Easily-parseable/retrievable ID or TAG or CLASS selectors
664	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
665
666	rsibling = /[+~]/,
667
668	// CSS escapes
669	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
670	runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
671	funescape = function( escape, nonHex ) {
672		var high = "0x" + escape.slice( 1 ) - 0x10000;
673
674		return nonHex ?
675
676			// Strip the backslash prefix from a non-hex escape sequence
677			nonHex :
678
679			// Replace a hexadecimal escape sequence with the encoded Unicode code point
680			// Support: IE <=11+
681			// For values outside the Basic Multilingual Plane (BMP), manually construct a
682			// surrogate pair
683			high < 0 ?
684				String.fromCharCode( high + 0x10000 ) :
685				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
686	},
687
688	// CSS string/identifier serialization
689	// https://drafts.csswg.org/cssom/#common-serializing-idioms
690	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
691	fcssescape = function( ch, asCodePoint ) {
692		if ( asCodePoint ) {
693
694			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
695			if ( ch === "\0" ) {
696				return "\uFFFD";
697			}
698
699			// Control characters and (dependent upon position) numbers get escaped as code points
700			return ch.slice( 0, -1 ) + "\\" +
701				ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
702		}
703
704		// Other potentially-special ASCII characters get backslash-escaped
705		return "\\" + ch;
706	},
707
708	// Used for iframes
709	// See setDocument()
710	// Removing the function wrapper causes a "Permission Denied"
711	// error in IE
712	unloadHandler = function() {
713		setDocument();
714	},
715
716	inDisabledFieldset = addCombinator(
717		function( elem ) {
718			return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
719		},
720		{ dir: "parentNode", next: "legend" }
721	);
722
723// Optimize for push.apply( _, NodeList )
724try {
725	push.apply(
726		( arr = slice.call( preferredDoc.childNodes ) ),
727		preferredDoc.childNodes
728	);
729
730	// Support: Android<4.0
731	// Detect silently failing push.apply
732	// eslint-disable-next-line no-unused-expressions
733	arr[ preferredDoc.childNodes.length ].nodeType;
734} catch ( e ) {
735	push = { apply: arr.length ?
736
737		// Leverage slice if possible
738		function( target, els ) {
739			pushNative.apply( target, slice.call( els ) );
740		} :
741
742		// Support: IE<9
743		// Otherwise append directly
744		function( target, els ) {
745			var j = target.length,
746				i = 0;
747
748			// Can't trust NodeList.length
749			while ( ( target[ j++ ] = els[ i++ ] ) ) {}
750			target.length = j - 1;
751		}
752	};
753}
754
755function Sizzle( selector, context, results, seed ) {
756	var m, i, elem, nid, match, groups, newSelector,
757		newContext = context && context.ownerDocument,
758
759		// nodeType defaults to 9, since context defaults to document
760		nodeType = context ? context.nodeType : 9;
761
762	results = results || [];
763
764	// Return early from calls with invalid selector or context
765	if ( typeof selector !== "string" || !selector ||
766		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
767
768		return results;
769	}
770
771	// Try to shortcut find operations (as opposed to filters) in HTML documents
772	if ( !seed ) {
773		setDocument( context );
774		context = context || document;
775
776		if ( documentIsHTML ) {
777
778			// If the selector is sufficiently simple, try using a "get*By*" DOM method
779			// (excepting DocumentFragment context, where the methods don't exist)
780			if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
781
782				// ID selector
783				if ( ( m = match[ 1 ] ) ) {
784
785					// Document context
786					if ( nodeType === 9 ) {
787						if ( ( elem = context.getElementById( m ) ) ) {
788

789							// Support: IE, Opera, Webkit
790							// TODO: identify versions
791							// getElementById can match elements by name instead of ID
792							if ( elem.id === m ) {
793								results.push( elem );
794								return results;
795							}
796						} else {
797							return results;
798						}
799
800					// Element context
801					} else {
802
803						// Support: IE, Opera, Webkit
804						// TODO: identify versions
805						// getElementById can match elements by name instead of ID
806						if ( newContext && ( elem = newContext.getElementById( m ) ) &&
807							contains( context, elem ) &&
808							elem.id === m ) {
809
810							results.push( elem );
811							return results;
812						}
813					}
814
815				// Type selector
816				} else if ( match[ 2 ] ) {
817					push.apply( results, context.getElementsByTagName( selector ) );
818					return results;
819
820				// Class selector
821				} else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&
822					context.getElementsByClassName ) {
823
824					push.apply( results, context.getElementsByClassName( m ) );
825					return results;
826				}
827			}
828
829			// Take advantage of querySelectorAll
830			if ( support.qsa &&
831				!nonnativeSelectorCache[ selector + " " ] &&
832				( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&
833
834				// Support: IE 8 only
835				// Exclude object elements
836				( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) {
837
838				newSelector = selector;
839				newContext = context;
840
841				// qSA considers elements outside a scoping root when evaluating child or
842				// descendant combinators, which is not what we want.
843				// In such cases, we work around the behavior by prefixing every selector in the
844				// list with an ID selector referencing the scope context.
845				// The technique has to be used as well when a leading combinator is used
846				// as such selectors are not recognized by querySelectorAll.
847				// Thanks to Andrew Dupont for this technique.
848				if ( nodeType === 1 &&
849					( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
850
851					// Expand context for sibling selectors
852					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
853						context;
854
855					// We can use :scope instead of the ID hack if the browser
856					// supports it & if we're not changing the context.
857					if ( newContext !== context || !support.scope ) {
858
859						// Capture the context ID, setting it first if necessary
860						if ( ( nid = context.getAttribute( "id" ) ) ) {
861							nid = nid.replace( rcssescape, fcssescape );
862						} else {
863							context.setAttribute( "id", ( nid = expando ) );
864						}
865					}
866
867					// Prefix every selector in the list
868					groups = tokenize( selector );
869					i = groups.length;
870					while ( i-- ) {
871						groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
872							toSelector( groups[ i ] );
873					}
874					newSelector = groups.join( "," );
875				}
876
877				try {
878					push.apply( results,
879						newContext.querySelectorAll( newSelector )
880					);
881					return results;
882				} catch ( qsaError ) {
883					nonnativeSelectorCache( selector, true );
884				} finally {
885					if ( nid === expando ) {
886						context.removeAttribute( "id" );
887					}
888				}
889			}
890		}
891	}
892
893	// All others
894	return select( selector.replace( rtrim, "$1" ), context, results, seed );
895}
896
897/**
898 * Create key-value caches of limited size
899 * @returns {function(string, object)} Returns the Object data after storing it on itself with
900 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
901 *	deleting the oldest entry
902 */
903function createCache() {
904	var keys = [];
905
906	function cache( key, value ) {
907
908		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
909		if ( keys.push( key + " " ) > Expr.cacheLength ) {
910
911			// Only keep the most recent entries
912			delete cache[ keys.shift() ];
913		}
914		return ( cache[ key + " " ] = value );
915	}
916	return cache;
917}
918
919/**
920 * Mark a function for special use by Sizzle
921 * @param {Function} fn The function to mark
922 */
923function markFunction( fn ) {
924	fn[ expando ] = true;
925	return fn;
926}
927
928/**
929 * Support testing using an element
930 * @param {Function} fn Passed the created element and returns a boolean result
931 */
932function assert( fn ) {
933	var el = document.createElement( "fieldset" );
934
935	try {
936		return !!fn( el );
937	} catch ( e ) {
938		return false;

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

1648	// Support: IE 11+, Edge 17 - 18+
1649	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1650	// two documents; shallow comparisons work.
1651	// eslint-disable-next-line eqeqeq
1652	if ( ( elem.ownerDocument || elem ) != document ) {
1653		setDocument( elem );
1654	}
1655
1656	var fn = Expr.attrHandle[ name.toLowerCase() ],
1657
1658		// Don't get fooled by Object.prototype properties (jQuery #13807)
1659		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1660			fn( elem, name, !documentIsHTML ) :
1661			undefined;
1662
1663	return val !== undefined ?
1664		val :
1665		support.attributes || !documentIsHTML ?
1666			elem.getAttribute( name ) :
1667			( val = elem.getAttributeNode( name ) ) && val.specified ?
1668				val.value :
1669				null;
1670};
1671
1672Sizzle.escape = function( sel ) {
1673	return ( sel + "" ).replace( rcssescape, fcssescape );
1674};
1675
1676Sizzle.error = function( msg ) {
1677	throw new Error( "Syntax error, unrecognized expression: " + msg );
1678};
1679
1680/**
1681 * Document sorting and removing duplicates
1682 * @param {ArrayLike} results
1683 */
1684Sizzle.uniqueSort = function( results ) {
1685	var elem,
1686		duplicates = [],
1687		j = 0,
1688		i = 0;
1689
1690	// Unless we *know* we can detect duplicates, assume their presence
1691	hasDuplicate = !support.detectDuplicates;
1692	sortInput = !support.sortStable && results.slice( 0 );
1693	results.sort( sortOrder );
1694
1695	if ( hasDuplicate ) {
1696		while ( ( elem = results[ i++ ] ) ) {
1697			if ( elem === results[ i ] ) {
1698				j = duplicates.push( i );
1699			}
1700		}
1701		while ( j-- ) {
1702			results.splice( duplicates[ j ], 1 );
1703		}
1704	}
1705
1706	// Clear input after sorting to release objects
1707	// See https://github.com/jquery/sizzle/pull/225
1708	sortInput = null;
1709
1710	return results;
1711};
1712
1713/**
1714 * Utility function for retrieving the text value of an array of DOM nodes
1715 * @param {Array|Element} elem
1716 */
1717getText = Sizzle.getText = function( elem ) {
1718	var node,
1719		ret = "",
1720		i = 0,
1721		nodeType = elem.nodeType;
1722
1723	if ( !nodeType ) {
1724
1725		// If no nodeType, this is expected to be an array
1726		while ( ( node = elem[ i++ ] ) ) {
1727
1728			// Do not traverse comment nodes
1729			ret += getText( node );
1730		}
1731	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1732
1733		// Use textContent for elements
1734		// innerText usage removed for consistency of new lines (jQuery #11153)
1735		if ( typeof elem.textContent === "string" ) {
1736			return elem.textContent;
1737		} else {
1738
1739			// Traverse its children
1740			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1741				ret += getText( elem );
1742			}
1743		}
1744	} else if ( nodeType === 3 || nodeType === 4 ) {
1745		return elem.nodeValue;
1746	}
1747
1748	// Do not include comment or processing instruction nodes
1749
1750	return ret;
1751};
1752
1753Expr = Sizzle.selectors = {
1754
1755	// Can be adjusted by the user
1756	cacheLength: 50,
1757
1758	createPseudo: markFunction,
1759
1760	match: matchExpr,
1761
1762	attrHandle: {},
1763
1764	find: {},
1765
1766	relative: {
1767		">": { dir: "parentNode", first: true },
1768		" ": { dir: "parentNode" },
1769		"+": { dir: "previousSibling", first: true },
1770		"~": { dir: "previousSibling" }
1771	},
1772
1773	preFilter: {
1774		"ATTR": function( match ) {
1775			match[ 1 ] = match[ 1 ].replace( runescape, funescape );
1776
1777			// Move the given value to match[3] whether quoted or unquoted
1778			match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||
1779				match[ 5 ] || "" ).replace( runescape, funescape );
1780
1781			if ( match[ 2 ] === "~=" ) {
1782				match[ 3 ] = " " + match[ 3 ] + " ";
1783			}
1784
1785			return match.slice( 0, 4 );
1786		},
1787
1788		"CHILD": function( match ) {
1789
1790			/* matches from matchExpr["CHILD"]
1791				1 type (only|nth|...)
1792				2 what (child|of-type)
1793				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1794				4 xn-component of xn+y argument ([+-]?\d*n|)
1795				5 sign of xn-component
1796				6 x of xn-component
1797				7 sign of y-component
1798				8 y of y-component
1799			*/
1800			match[ 1 ] = match[ 1 ].toLowerCase();
1801
1802			if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
1803
1804				// nth-* requires argument
1805				if ( !match[ 3 ] ) {
1806					Sizzle.error( match[ 0 ] );
1807				}
1808
1809				// numeric x and y parameters for Expr.filter.CHILD
1810				// remember that false/true cast respectively to 0/1
1811				match[ 4 ] = +( match[ 4 ] ?
1812					match[ 5 ] + ( match[ 6 ] || 1 ) :
1813					2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) );
1814				match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
1815
1816				// other types prohibit arguments
1817			} else if ( match[ 3 ] ) {
1818				Sizzle.error( match[ 0 ] );
1819			}
1820
1821			return match;
1822		},
1823
1824		"PSEUDO": function( match ) {
1825			var excess,
1826				unquoted = !match[ 6 ] && match[ 2 ];
1827
1828			if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) {
1829				return null;
1830			}
1831
1832			// Accept quoted arguments as-is
1833			if ( match[ 3 ] ) {
1834				match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
1835
1836			// Strip excess characters from unquoted arguments
1837			} else if ( unquoted && rpseudo.test( unquoted ) &&
1838
1839				// Get excess from tokenize (recursively)
1840				( excess = tokenize( unquoted, true ) ) &&
1841
1842				// advance to the next closing parenthesis
1843				( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
1844
1845				// excess is a negative index
1846				match[ 0 ] = match[ 0 ].slice( 0, excess );
1847				match[ 2 ] = unquoted.slice( 0, excess );
1848			}
1849
1850			// Return only captures needed by the pseudo filter method (type and argument)
1851			return match.slice( 0, 3 );
1852		}
1853	},
1854
1855	filter: {
1856
1857		"TAG": function( nodeNameSelector ) {
1858			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1859			return nodeNameSelector === "*" ?
1860				function() {
1861					return true;
1862				} :
1863				function( elem ) {
1864					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1865				};
1866		},
1867
1868		"CLASS": function( className ) {
1869			var pattern = classCache[ className + " " ];
1870
1871			return pattern ||
1872				( pattern = new RegExp( "(^|" + whitespace +
1873					")" + className + "(" + whitespace + "|$)" ) ) && classCache(
1874						className, function( elem ) {
1875							return pattern.test(
1876								typeof elem.className === "string" && elem.className ||
1877								typeof elem.getAttribute !== "undefined" &&
1878									elem.getAttribute( "class" ) ||
1879								""
1880							);
1881				} );
1882		},
1883
1884		"ATTR": function( name, operator, check ) {
1885			return function( elem ) {
1886				var result = Sizzle.attr( elem, name );
1887
1888				if ( result == null ) {
1889					return operator === "!=";
1890				}
1891				if ( !operator ) {
1892					return true;
1893				}
1894
1895				result += "";
1896
1897				/* eslint-disable max-len */
1898
1899				return operator === "=" ? result === check :
1900					operator === "!=" ? result !== check :
1901					operator === "^=" ? check && result.indexOf( check ) === 0 :
1902					operator === "*=" ? check && result.indexOf( check ) > -1 :
1903					operator === "$=" ? check && result.slice( -check.length ) === check :
1904					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1905					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1906					false;
1907				/* eslint-enable max-len */
1908
1909			};
1910		},
1911
1912		"CHILD": function( type, what, _argument, first, last ) {
1913			var simple = type.slice( 0, 3 ) !== "nth",
1914				forward = type.slice( -4 ) !== "last",
1915				ofType = what === "of-type";
1916
1917			return first === 1 && last === 0 ?
1918
1919				// Shortcut for :nth-*(n)
1920				function( elem ) {
1921					return !!elem.parentNode;
1922				} :
1923
1924				function( elem, _context, xml ) {
1925					var cache, uniqueCache, outerCache, node, nodeIndex, start,
1926						dir = simple !== forward ? "nextSibling" : "previousSibling",
1927						parent = elem.parentNode,
1928						name = ofType && elem.nodeName.toLowerCase(),
1929						useCache = !xml && !ofType,
1930						diff = false;
1931
1932					if ( parent ) {
1933
1934						// :(first|last|only)-(child|of-type)
1935						if ( simple ) {
1936							while ( dir ) {
1937								node = elem;
1938								while ( ( node = node[ dir ] ) ) {
1939									if ( ofType ?
1940										node.nodeName.toLowerCase() === name :
1941										node.nodeType === 1 ) {
1942
1943										return false;
1944									}
1945								}
1946
1947								// Reverse direction for :only-* (if we haven't yet done so)
1948								start = dir = type === "only" && !start && "nextSibling";
1949							}
1950							return true;
1951						}
1952
1953						start = [ forward ? parent.firstChild : parent.lastChild ];
1954
1955						// non-xml :nth-child(...) stores cache data on `parent`
1956						if ( forward && useCache ) {
1957
1958							// Seek `elem` from a previously-cached index
1959
1960							// ...in a gzip-friendly way
1961							node = parent;
1962							outerCache = node[ expando ] || ( node[ expando ] = {} );
1963
1964							// Support: IE <9 only
1965							// Defend against cloned attroperties (jQuery gh-1709)
1966							uniqueCache = outerCache[ node.uniqueID ] ||
1967								( outerCache[ node.uniqueID ] = {} );
1968
1969							cache = uniqueCache[ type ] || [];
1970							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1971							diff = nodeIndex && cache[ 2 ];
1972							node = nodeIndex && parent.childNodes[ nodeIndex ];
1973
1974							while ( ( node = ++nodeIndex && node && node[ dir ] ||
1975
1976								// Fallback to seeking `elem` from the start
1977								( diff = nodeIndex = 0 ) || start.pop() ) ) {
1978
1979								// When found, cache indexes on `parent` and break
1980								if ( node.nodeType === 1 && ++diff && node === elem ) {
1981									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1982									break;
1983								}
1984							}
1985
1986						} else {
1987
1988							// Use previously-cached element index if available
1989							if ( useCache ) {
1990
1991								// ...in a gzip-friendly way
1992								node = elem;
1993								outerCache = node[ expando ] || ( node[ expando ] = {} );
1994
1995								// Support: IE <9 only
1996								// Defend against cloned attroperties (jQuery gh-1709)
1997								uniqueCache = outerCache[ node.uniqueID ] ||
1998									( outerCache[ node.uniqueID ] = {} );
1999
2000								cache = uniqueCache[ type ] || [];
2001								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
2002								diff = nodeIndex;
2003							}
2004
2005							// xml :nth-child(...)
2006							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
2007							if ( diff === false ) {
2008
2009								// Use the same loop as above to seek `elem` from the start
2010								while ( ( node = ++nodeIndex && node && node[ dir ] ||
2011									( diff = nodeIndex = 0 ) || start.pop() ) ) {
2012
2013									if ( ( ofType ?
2014										node.nodeName.toLowerCase() === name :
2015										node.nodeType === 1 ) &&
2016										++diff ) {
2017
2018										// Cache the index of each encountered element
2019										if ( useCache ) {
2020											outerCache = node[ expando ] ||
2021												( node[ expando ] = {} );
2022
2023											// Support: IE <9 only
2024											// Defend against cloned attroperties (jQuery gh-1709)
2025											uniqueCache = outerCache[ node.uniqueID ] ||
2026												( outerCache[ node.uniqueID ] = {} );
2027
2028											uniqueCache[ type ] = [ dirruns, diff ];
2029										}
2030
2031										if ( node === elem ) {
2032											break;
2033										}
2034									}
2035								}
2036							}
2037						}
2038
2039						// Incorporate the offset, then check against cycle size
2040						diff -= last;
2041						return diff === first || ( diff % first === 0 && diff / first >= 0 );
2042					}
2043				};
2044		},
2045
2046		"PSEUDO": function( pseudo, argument ) {
2047
2048			// pseudo-class names are case-insensitive
2049			// http://www.w3.org/TR/selectors/#pseudo-classes
2050			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2051			// Remember that setFilters inherits from pseudos
2052			var args,
2053				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2054					Sizzle.error( "unsupported pseudo: " + pseudo );
2055
2056			// The user may use createPseudo to indicate that
2057			// arguments are needed to create the filter function
2058			// just as Sizzle does
2059			if ( fn[ expando ] ) {
2060				return fn( argument );
2061			}
2062
2063			// But maintain support for old signatures
2064			if ( fn.length > 1 ) {
2065				args = [ pseudo, pseudo, "", argument ];
2066				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2067					markFunction( function( seed, matches ) {
2068						var idx,
2069							matched = fn( seed, argument ),
2070							i = matched.length;
2071						while ( i-- ) {
2072							idx = indexOf( seed, matched[ i ] );
2073							seed[ idx ] = !( matches[ idx ] = matched[ i ] );
2074						}
2075					} ) :
2076					function( elem ) {
2077						return fn( elem, 0, args );
2078					};
2079			}
2080
2081			return fn;
2082		}
2083	},
2084
2085	pseudos: {
2086
2087		// Potentially complex pseudos
2088		"not": markFunction( function( selector ) {
2089
2090			// Trim the selector passed to compile
2091			// to avoid treating leading and trailing
2092			// spaces as combinators
2093			var input = [],
2094				results = [],
2095				matcher = compile( selector.replace( rtrim, "$1" ) );
2096
2097			return matcher[ expando ] ?
2098				markFunction( function( seed, matches, _context, xml ) {
2099					var elem,
2100						unmatched = matcher( seed, null, xml, [] ),
2101						i = seed.length;
2102
2103					// Match elements unmatched by `matcher`
2104					while ( i-- ) {
2105						if ( ( elem = unmatched[ i ] ) ) {
2106							seed[ i ] = !( matches[ i ] = elem );
2107						}
2108					}
2109				} ) :
2110				function( elem, _context, xml ) {
2111					input[ 0 ] = elem;
2112					matcher( input, null, xml, results );
2113
2114					// Don't keep the element (issue #299)
2115					input[ 0 ] = null;
2116					return !results.pop();
2117				};
2118		} ),
2119
2120		"has": markFunction( function( selector ) {
2121			return function( elem ) {
2122				return Sizzle( selector, elem ).length > 0;
2123			};
2124		} ),
2125
2126		"contains": markFunction( function( text ) {
2127			text = text.replace( runescape, funescape );
2128			return function( elem ) {
2129				return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
2130			};
2131		} ),
2132
2133		// "Whether an element is represented by a :lang() selector
2134		// is based solely on the element's language value
2135		// being equal to the identifier C,
2136		// or beginning with the identifier C immediately followed by "-".
2137		// The matching of C against the element's language value is performed case-insensitively.
2138		// The identifier C does not have to be a valid language name."
2139		// http://www.w3.org/TR/selectors/#lang-pseudo
2140		"lang": markFunction( function( lang ) {
2141
2142			// lang value must be a valid identifier
2143			if ( !ridentifier.test( lang || "" ) ) {
2144				Sizzle.error( "unsupported lang: " + lang );
2145			}
2146			lang = lang.replace( runescape, funescape ).toLowerCase();
2147			return function( elem ) {
2148				var elemLang;
2149				do {
2150					if ( ( elemLang = documentIsHTML ?
2151						elem.lang :
2152						elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
2153
2154						elemLang = elemLang.toLowerCase();
2155						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2156					}
2157				} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
2158				return false;
2159			};
2160		} ),
2161
2162		// Miscellaneous
2163		"target": function( elem ) {
2164			var hash = window.location && window.location.hash;
2165			return hash && hash.slice( 1 ) === elem.id;
2166		},
2167
2168		"root": function( elem ) {
2169			return elem === docElem;
2170		},
2171
2172		"focus": function( elem ) {
2173			return elem === document.activeElement &&
2174				( !document.hasFocus || document.hasFocus() ) &&
2175				!!( elem.type || elem.href || ~elem.tabIndex );
2176		},
2177
2178		// Boolean properties
2179		"enabled": createDisabledPseudo( false ),
2180		"disabled": createDisabledPseudo( true ),
2181
2182		"checked": function( elem ) {
2183
2184			// In CSS3, :checked should return both checked and selected elements
2185			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2186			var nodeName = elem.nodeName.toLowerCase();
2187			return ( nodeName === "input" && !!elem.checked ) ||
2188				( nodeName === "option" && !!elem.selected );
2189		},
2190
2191		"selected": function( elem ) {
2192
2193			// Accessing this property makes selected-by-default
2194			// options in Safari work properly
2195			if ( elem.parentNode ) {
2196				// eslint-disable-next-line no-unused-expressions
2197				elem.parentNode.selectedIndex;
2198			}
2199
2200			return elem.selected === true;
2201		},
2202
2203		// Contents
2204		"empty": function( elem ) {
2205
2206			// http://www.w3.org/TR/selectors/#empty-pseudo
2207			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2208			//   but not by others (comment: 8; processing instruction: 7; etc.)
2209			// nodeType < 6 works because attributes (2) do not appear as children
2210			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2211				if ( elem.nodeType < 6 ) {
2212					return false;
2213				}
2214			}
2215			return true;
2216		},
2217
2218		"parent": function( elem ) {
2219			return !Expr.pseudos[ "empty" ]( elem );
2220		},
2221
2222		// Element/input types
2223		"header": function( elem ) {
2224			return rheader.test( elem.nodeName );
2225		},
2226
2227		"input": function( elem ) {
2228			return rinputs.test( elem.nodeName );
2229		},
2230
2231		"button": function( elem ) {
2232			var name = elem.nodeName.toLowerCase();
2233			return name === "input" && elem.type === "button" || name === "button";
2234		},
2235
2236		"text": function( elem ) {
2237			var attr;
2238			return elem.nodeName.toLowerCase() === "input" &&
2239				elem.type === "text" &&
2240
2241				// Support: IE<8
2242				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2243				( ( attr = elem.getAttribute( "type" ) ) == null ||
2244					attr.toLowerCase() === "text" );
2245		},
2246
2247		// Position-in-collection
2248		"first": createPositionalPseudo( function() {
2249			return [ 0 ];
2250		} ),
2251
2252		"last": createPositionalPseudo( function( _matchIndexes, length ) {
2253			return [ length - 1 ];
2254		} ),
2255
2256		"eq": createPositionalPseudo( function( _matchIndexes, length, argument ) {
2257			return [ argument < 0 ? argument + length : argument ];
2258		} ),
2259
2260		"even": createPositionalPseudo( function( matchIndexes, length ) {
2261			var i = 0;
2262			for ( ; i < length; i += 2 ) {
2263				matchIndexes.push( i );
2264			}
2265			return matchIndexes;
2266		} ),
2267
2268		"odd": createPositionalPseudo( function( matchIndexes, length ) {
2269			var i = 1;
2270			for ( ; i < length; i += 2 ) {
2271				matchIndexes.push( i );
2272			}
2273			return matchIndexes;
2274		} ),
2275
2276		"lt": createPositionalPseudo( function( matchIndexes, length, argument ) {
2277			var i = argument < 0 ?
2278				argument + length :
2279				argument > length ?
2280					length :
2281					argument;
2282			for ( ; --i >= 0; ) {
2283				matchIndexes.push( i );
2284			}
2285			return matchIndexes;
2286		} ),
2287
2288		"gt": createPositionalPseudo( function( matchIndexes, length, argument ) {
2289			var i = argument < 0 ? argument + length : argument;
2290			for ( ; ++i < length; ) {
2291				matchIndexes.push( i );
2292			}
2293			return matchIndexes;
2294		} )
2295	}
2296};
2297
2298Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ];
2299
2300// Add button/input type pseudos
2301for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2302	Expr.pseudos[ i ] = createInputPseudo( i );
2303}
2304for ( i in { submit: true, reset: true } ) {
2305	Expr.pseudos[ i ] = createButtonPseudo( i );
2306}
2307
2308// Easy API for creating new setFilters
2309function setFilters() {}
2310setFilters.prototype = Expr.filters = Expr.pseudos;
2311Expr.setFilters = new setFilters();
2312
2313tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2314	var matched, match, tokens, type,
2315		soFar, groups, preFilters,
2316		cached = tokenCache[ selector + " " ];
2317
2318	if ( cached ) {
2319		return parseOnly ? 0 : cached.slice( 0 );
2320	}
2321
2322	soFar = selector;
2323	groups = [];
2324	preFilters = Expr.preFilter;
2325
2326	while ( soFar ) {
2327
2328		// Comma and first run
2329		if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
2330			if ( match ) {
2331
2332				// Don't consume trailing commas as valid
2333				soFar = soFar.slice( match[ 0 ].length ) || soFar;
2334			}
2335			groups.push( ( tokens = [] ) );
2336		}
2337
2338		matched = false;
2339
2340		// Combinators
2341		if ( ( match = rcombinators.exec( soFar ) ) ) {
2342			matched = match.shift();
2343			tokens.push( {
2344				value: matched,
2345
2346				// Cast descendant combinators to space
2347				type: match[ 0 ].replace( rtrim, " " )
2348			} );
2349			soFar = soFar.slice( matched.length );
2350		}
2351
2352		// Filters
2353		for ( type in Expr.filter ) {
2354			if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
2355				( match = preFilters[ type ]( match ) ) ) ) {
2356				matched = match.shift();
2357				tokens.push( {
2358					value: matched,
2359					type: type,
2360					matches: match
2361				} );
2362				soFar = soFar.slice( matched.length );
2363			}
2364		}
2365
2366		if ( !matched ) {
2367			break;
2368		}
2369	}
2370
2371	// Return the length of the invalid excess
2372	// if we're just parsing
2373	// Otherwise, throw an error or return tokens
2374	return parseOnly ?
2375		soFar.length :
2376		soFar ?
2377			Sizzle.error( selector ) :
2378
2379			// Cache the tokens
2380			tokenCache( selector, groups ).slice( 0 );
2381};
2382
2383function toSelector( tokens ) {
2384	var i = 0,
2385		len = tokens.length,
2386		selector = "";
2387	for ( ; i < len; i++ ) {
2388		selector += tokens[ i ].value;
2389	}
2390	return selector;
2391}
2392
2393function addCombinator( matcher, combinator, base ) {
2394	var dir = combinator.dir,
2395		skip = combinator.next,
2396		key = skip || dir,
2397		checkNonElements = base && key === "parentNode",
2398		doneName = done++;
2399
2400	return combinator.first ?
2401
2402		// Check against closest ancestor/preceding element
2403		function( elem, context, xml ) {
2404			while ( ( elem = elem[ dir ] ) ) {
2405				if ( elem.nodeType === 1 || checkNonElements ) {
2406					return matcher( elem, context, xml );
2407				}
2408			}
2409			return false;
2410		} :
2411
2412		// Check against all ancestor/preceding elements
2413		function( elem, context, xml ) {
2414			var oldCache, uniqueCache, outerCache,
2415				newCache = [ dirruns, doneName ];
2416
2417			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2418			if ( xml ) {
2419				while ( ( elem = elem[ dir ] ) ) {
2420					if ( elem.nodeType === 1 || checkNonElements ) {
2421						if ( matcher( elem, context, xml ) ) {
2422							return true;
2423						}
2424					}
2425				}
2426			} else {
2427				while ( ( elem = elem[ dir ] ) ) {
2428					if ( elem.nodeType === 1 || checkNonElements ) {
2429						outerCache = elem[ expando ] || ( elem[ expando ] = {} );
2430
2431						// Support: IE <9 only
2432						// Defend against cloned attroperties (jQuery gh-1709)
2433						uniqueCache = outerCache[ elem.uniqueID ] ||
2434							( outerCache[ elem.uniqueID ] = {} );
2435
2436						if ( skip && skip === elem.nodeName.toLowerCase() ) {
2437							elem = elem[ dir ] || elem;
2438						} else if ( ( oldCache = uniqueCache[ key ] ) &&
2439							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2440
2441							// Assign to newCache so results back-propagate to previous elements
2442							return ( newCache[ 2 ] = oldCache[ 2 ] );
2443						} else {
2444
2445							// Reuse newcache so results back-propagate to previous elements
2446							uniqueCache[ key ] = newCache;
2447
2448							// A match means we're done; a fail means we have to keep checking
2449							if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
2450								return true;
2451							}
2452						}
2453					}
2454				}
2455			}
2456			return false;
2457		};
2458}
2459
2460function elementMatcher( matchers ) {
2461	return matchers.length > 1 ?
2462		function( elem, context, xml ) {
2463			var i = matchers.length;
2464			while ( i-- ) {
2465				if ( !matchers[ i ]( elem, context, xml ) ) {
2466					return false;
2467				}
2468			}
2469			return true;
2470		} :
2471		matchers[ 0 ];
2472}
2473
2474function multipleContexts( selector, contexts, results ) {
2475	var i = 0,
2476		len = contexts.length;
2477	for ( ; i < len; i++ ) {
2478		Sizzle( selector, contexts[ i ], results );
2479	}
2480	return results;
2481}
2482
2483function condense( unmatched, map, filter, context, xml ) {
2484	var elem,
2485		newUnmatched = [],
2486		i = 0,
2487		len = unmatched.length,
2488		mapped = map != null;
2489
2490	for ( ; i < len; i++ ) {
2491		if ( ( elem = unmatched[ i ] ) ) {
2492			if ( !filter || filter( elem, context, xml ) ) {
2493				newUnmatched.push( elem );
2494				if ( mapped ) {
2495					map.push( i );
2496				}
2497			}
2498		}
2499	}
2500
2501	return newUnmatched;
2502}
2503
2504function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2505	if ( postFilter && !postFilter[ expando ] ) {
2506		postFilter = setMatcher( postFilter );
2507	}
2508	if ( postFinder && !postFinder[ expando ] ) {
2509		postFinder = setMatcher( postFinder, postSelector );
2510	}
2511	return markFunction( function( seed, results, context, xml ) {
2512		var temp, i, elem,
2513			preMap = [],
2514			postMap = [],
2515			preexisting = results.length,
2516
2517			// Get initial elements from seed or context
2518			elems = seed || multipleContexts(
2519				selector || "*",
2520				context.nodeType ? [ context ] : context,
2521				[]
2522			),
2523
2524			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2525			matcherIn = preFilter && ( seed || !selector ) ?
2526				condense( elems, preMap, preFilter, context, xml ) :
2527				elems,
2528
2529			matcherOut = matcher ?
2530
2531				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2532				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2533
2534					// ...intermediate processing is necessary
2535					[] :
2536
2537					// ...otherwise use results directly
2538					results :
2539				matcherIn;
2540
2541		// Find primary matches
2542		if ( matcher ) {
2543			matcher( matcherIn, matcherOut, context, xml );
2544		}
2545
2546		// Apply postFilter
2547		if ( postFilter ) {
2548			temp = condense( matcherOut, postMap );
2549			postFilter( temp, [], context, xml );
2550
2551			// Un-match failing elements by moving them back to matcherIn
2552			i = temp.length;
2553			while ( i-- ) {
2554				if ( ( elem = temp[ i ] ) ) {
2555					matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
2556				}
2557			}
2558		}
2559
2560		if ( seed ) {
2561			if ( postFinder || preFilter ) {
2562				if ( postFinder ) {
2563
2564					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2565					temp = [];
2566					i = matcherOut.length;
2567					while ( i-- ) {
2568						if ( ( elem = matcherOut[ i ] ) ) {
2569
2570							// Restore matcherIn since elem is not yet a final match
2571							temp.push( ( matcherIn[ i ] = elem ) );
2572						}
2573					}
2574					postFinder( null, ( matcherOut = [] ), temp, xml );
2575				}
2576
2577				// Move matched elements from seed to results to keep them synchronized
2578				i = matcherOut.length;
2579				while ( i-- ) {
2580					if ( ( elem = matcherOut[ i ] ) &&
2581						( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {
2582
2583						seed[ temp ] = !( results[ temp ] = elem );
2584					}
2585				}
2586			}
2587
2588		// Add elements to results, through postFinder if defined
2589		} else {
2590			matcherOut = condense(
2591				matcherOut === results ?
2592					matcherOut.splice( preexisting, matcherOut.length ) :
2593					matcherOut
2594			);
2595			if ( postFinder ) {
2596				postFinder( null, results, matcherOut, xml );
2597			} else {
2598				push.apply( results, matcherOut );
2599			}
2600		}
2601	} );
2602}
2603
2604function matcherFromTokens( tokens ) {
2605	var checkContext, matcher, j,
2606		len = tokens.length,
2607		leadingRelative = Expr.relative[ tokens[ 0 ].type ],
2608		implicitRelative = leadingRelative || Expr.relative[ " " ],
2609		i = leadingRelative ? 1 : 0,
2610
2611		// The foundational matcher ensures that elements are reachable from top-level context(s)
2612		matchContext = addCombinator( function( elem ) {
2613			return elem === checkContext;
2614		}, implicitRelative, true ),
2615		matchAnyContext = addCombinator( function( elem ) {
2616			return indexOf( checkContext, elem ) > -1;
2617		}, implicitRelative, true ),
2618		matchers = [ function( elem, context, xml ) {
2619			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2620				( checkContext = context ).nodeType ?
2621					matchContext( elem, context, xml ) :
2622					matchAnyContext( elem, context, xml ) );
2623
2624			// Avoid hanging onto element (issue #299)
2625			checkContext = null;
2626			return ret;
2627		} ];
2628
2629	for ( ; i < len; i++ ) {
2630		if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
2631			matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
2632		} else {
2633			matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
2634
2635			// Return special upon seeing a positional matcher
2636			if ( matcher[ expando ] ) {
2637
2638				// Find the next relative operator (if any) for proper handling
2639				j = ++i;
2640				for ( ; j < len; j++ ) {
2641					if ( Expr.relative[ tokens[ j ].type ] ) {
2642						break;
2643					}
2644				}
2645				return setMatcher(
2646					i > 1 && elementMatcher( matchers ),
2647					i > 1 && toSelector(
2648
2649					// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2650					tokens
2651						.slice( 0, i - 1 )
2652						.concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
2653					).replace( rtrim, "$1" ),
2654					matcher,
2655					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2656					j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
2657					j < len && toSelector( tokens )
2658				);
2659			}
2660			matchers.push( matcher );
2661		}
2662	}
2663
2664	return elementMatcher( matchers );
2665}
2666
2667function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2668	var bySet = setMatchers.length > 0,
2669		byElement = elementMatchers.length > 0,
2670		superMatcher = function( seed, context, xml, results, outermost ) {
2671			var elem, j, matcher,
2672				matchedCount = 0,
2673				i = "0",
2674				unmatched = seed && [],
2675				setMatched = [],
2676				contextBackup = outermostContext,
2677
2678				// We must always have either seed elements or outermost context
2679				elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ),
2680
2681				// Use integer dirruns iff this is the outermost matcher
2682				dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
2683				len = elems.length;
2684
2685			if ( outermost ) {
2686
2687				// Support: IE 11+, Edge 17 - 18+
2688				// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2689				// two documents; shallow comparisons work.
2690				// eslint-disable-next-line eqeqeq
2691				outermostContext = context == document || context || outermost;
2692			}
2693
2694			// Add elements passing elementMatchers directly to results
2695			// Support: IE<9, Safari
2696			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2697			for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
2698				if ( byElement && elem ) {
2699					j = 0;
2700
2701					// Support: IE 11+, Edge 17 - 18+
2702					// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2703					// two documents; shallow comparisons work.
2704					// eslint-disable-next-line eqeqeq
2705					if ( !context && elem.ownerDocument != document ) {
2706						setDocument( elem );
2707						xml = !documentIsHTML;
2708					}
2709					while ( ( matcher = elementMatchers[ j++ ] ) ) {
2710						if ( matcher( elem, context || document, xml ) ) {
2711							results.push( elem );
2712							break;
2713						}
2714					}
2715					if ( outermost ) {
2716						dirruns = dirrunsUnique;
2717					}
2718				}
2719
2720				// Track unmatched elements for set filters
2721				if ( bySet ) {
2722
2723					// They will have gone through all possible matchers
2724					if ( ( elem = !matcher && elem ) ) {
2725						matchedCount--;
2726					}
2727
2728					// Lengthen the array for every element, matched or not
2729					if ( seed ) {
2730						unmatched.push( elem );
2731					}
2732				}
2733			}
2734
2735			// `i` is now the count of elements visited above, and adding it to `matchedCount`
2736			// makes the latter nonnegative.
2737			matchedCount += i;
2738
2739			// Apply set filters to unmatched elements
2740			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2741			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2742			// no element matchers and no seed.
2743			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2744			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2745			// numerically zero.
2746			if ( bySet && i !== matchedCount ) {
2747				j = 0;
2748				while ( ( matcher = setMatchers[ j++ ] ) ) {
2749					matcher( unmatched, setMatched, context, xml );
2750				}
2751
2752				if ( seed ) {
2753
2754					// Reintegrate element matches to eliminate the need for sorting
2755					if ( matchedCount > 0 ) {
2756						while ( i-- ) {
2757							if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
2758								setMatched[ i ] = pop.call( results );
2759							}
2760						}
2761					}
2762
2763					// Discard index placeholder values to get only actual matches
2764					setMatched = condense( setMatched );
2765				}
2766
2767				// Add matches to results
2768				push.apply( results, setMatched );
2769
2770				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2771				if ( outermost && !seed && setMatched.length > 0 &&
2772					( matchedCount + setMatchers.length ) > 1 ) {
2773
2774					Sizzle.uniqueSort( results );
2775				}
2776			}
2777
2778			// Override manipulation of globals by nested matchers
2779			if ( outermost ) {
2780				dirruns = dirrunsUnique;
2781				outermostContext = contextBackup;
2782			}
2783
2784			return unmatched;
2785		};
2786
2787	return bySet ?
2788		markFunction( superMatcher ) :
2789		superMatcher;
2790}
2791
2792compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2793	var i,
2794		setMatchers = [],
2795		elementMatchers = [],
2796		cached = compilerCache[ selector + " " ];
2797
2798	if ( !cached ) {
2799
2800		// Generate a function of recursive functions that can be used to check each element
2801		if ( !match ) {
2802			match = tokenize( selector );
2803		}
2804		i = match.length;
2805		while ( i-- ) {
2806			cached = matcherFromTokens( match[ i ] );
2807			if ( cached[ expando ] ) {
2808				setMatchers.push( cached );
2809			} else {
2810				elementMatchers.push( cached );
2811			}
2812		}
2813
2814		// Cache the compiled function
2815		cached = compilerCache(
2816			selector,
2817			matcherFromGroupMatchers( elementMatchers, setMatchers )
2818		);
2819
2820		// Save selector and tokenization
2821		cached.selector = selector;
2822	}
2823	return cached;
2824};
2825
2826/**
2827 * A low-level selection function that works with Sizzle's compiled
2828 *  selector functions
2829 * @param {String|Function} selector A selector or a pre-compiled
2830 *  selector function built with Sizzle.compile
2831 * @param {Element} context
2832 * @param {Array} [results]
2833 * @param {Array} [seed] A set of elements to match against
2834 */
2835select = Sizzle.select = function( selector, context, results, seed ) {
2836	var i, tokens, token, type, find,
2837		compiled = typeof selector === "function" && selector,
2838		match = !seed && tokenize( ( selector = compiled.selector || selector ) );
2839
2840	results = results || [];
2841
2842	// Try to minimize operations if there is only one selector in the list and no seed
2843	// (the latter of which guarantees us context)
2844	if ( match.length === 1 ) {
2845
2846		// Reduce context if the leading compound selector is an ID
2847		tokens = match[ 0 ] = match[ 0 ].slice( 0 );
2848		if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
2849			context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
2850
2851			context = ( Expr.find[ "ID" ]( token.matches[ 0 ]
2852				.replace( runescape, funescape ), context ) || [] )[ 0 ];
2853			if ( !context ) {
2854				return results;
2855
2856			// Precompiled matchers will still verify ancestry, so step up a level
2857			} else if ( compiled ) {
2858				context = context.parentNode;
2859			}
2860
2861			selector = selector.slice( tokens.shift().value.length );
2862		}
2863
2864		// Fetch a seed set for right-to-left matching
2865		i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length;
2866		while ( i-- ) {
2867			token = tokens[ i ];
2868
2869			// Abort if we hit a combinator
2870			if ( Expr.relative[ ( type = token.type ) ] ) {
2871				break;
2872			}
2873			if ( ( find = Expr.find[ type ] ) ) {
2874
2875				// Search, expanding context for leading sibling combinators
2876				if ( ( seed = find(
2877					token.matches[ 0 ].replace( runescape, funescape ),
2878					rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||
2879						context
2880				) ) ) {
2881
2882					// If seed is empty or no tokens remain, we can return early
2883					tokens.splice( i, 1 );
2884					selector = seed.length && toSelector( tokens );
2885					if ( !selector ) {
2886						push.apply( results, seed );
2887						return results;
2888					}
2889
2890					break;
2891				}
2892			}
2893		}
2894	}
2895
2896	// Compile and execute a filtering function if one is not provided
2897	// Provide `match` to avoid retokenization if we modified the selector above
2898	( compiled || compile( selector, match ) )(
2899		seed,
2900		context,
2901		!documentIsHTML,
2902		results,
2903		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2904	);
2905	return results;
2906};
2907
2908// One-time assignments
2909
2910// Sort stability
2911support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
2912
2913// Support: Chrome 14-35+
2914// Always assume duplicates if they aren't passed to the comparison function
2915support.detectDuplicates = !!hasDuplicate;
2916
2917// Initialize against the default document
2918setDocument();
2919
2920// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2921// Detached nodes confoundingly follow *each other*
2922support.sortDetached = assert( function( el ) {
2923
2924	// Should return 1, but returns 4 (following)
2925	return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
2926} );
2927
2928// Support: IE<8
2929// Prevent attribute/property "interpolation"
2930// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2931if ( !assert( function( el ) {
2932	el.innerHTML = "<a href='#'></a>";
2933	return el.firstChild.getAttribute( "href" ) === "#";
2934} ) ) {
2935	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2936		if ( !isXML ) {
2937			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2938		}
2939	} );
2940}
2941
2942// Support: IE<9
2943// Use defaultValue in place of getAttribute("value")
2944if ( !support.attributes || !assert( function( el ) {
2945	el.innerHTML = "<input/>";
2946	el.firstChild.setAttribute( "value", "" );
2947	return el.firstChild.getAttribute( "value" ) === "";
2948} ) ) {
2949	addHandle( "value", function( elem, _name, isXML ) {
2950		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2951			return elem.defaultValue;
2952		}
2953	} );
2954}
2955
2956// Support: IE<9
2957// Use getAttributeNode to fetch booleans when getAttribute lies
2958if ( !assert( function( el ) {
2959	return el.getAttribute( "disabled" ) == null;
2960} ) ) {
2961	addHandle( booleans, function( elem, name, isXML ) {
2962		var val;
2963		if ( !isXML ) {
2964			return elem[ name ] === true ? name.toLowerCase() :
2965				( val = elem.getAttributeNode( name ) ) && val.specified ?
2966					val.value :
2967					null;
2968		}
2969	} );
2970}
2971
2972return Sizzle;
2973
2974} )( window );
2975
2976
2977
2978jQuery.find = Sizzle;
2979jQuery.expr = Sizzle.selectors;
2980
2981// Deprecated
2982jQuery.expr[ ":" ] = jQuery.expr.pseudos;
2983jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2984jQuery.text = Sizzle.getText;
2985jQuery.isXMLDoc = Sizzle.isXML;
2986jQuery.contains = Sizzle.contains;
2987jQuery.escapeSelector = Sizzle.escape;
2988
2989
2990
2991
2992var dir = function( elem, dir, until ) {
2993	var matched = [],
2994		truncate = until !== undefined;
2995
2996	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
2997		if ( elem.nodeType === 1 ) {
2998			if ( truncate && jQuery( elem ).is( until ) ) {
2999				break;
3000			}
3001			matched.push( elem );
3002		}
3003	}
3004	return matched;
3005};
3006
3007
3008var siblings = function( n, elem ) {
3009	var matched = [];
3010
3011	for ( ; n; n = n.nextSibling ) {
3012		if ( n.nodeType === 1 && n !== elem ) {
3013			matched.push( n );
3014		}
3015	}
3016
3017	return matched;
3018};
3019
3020
3021var rneedsContext = jQuery.expr.match.needsContext;
3022
3023
3024
3025function nodeName( elem, name ) {
3026
3027  return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
3028
3029};
3030var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
3031
3032
3033
3034// Implement the identical functionality for filter and not
3035function winnow( elements, qualifier, not ) {
3036	if ( isFunction( qualifier ) ) {
3037		return jQuery.grep( elements, function( elem, i ) {
3038			return !!qualifier.call( elem, i, elem ) !== not;
3039		} );
3040	}
3041
3042	// Single element
3043	if ( qualifier.nodeType ) {
3044		return jQuery.grep( elements, function( elem ) {
3045			return ( elem === qualifier ) !== not;
3046		} );
3047	}
3048
3049	// Arraylike of elements (jQuery, arguments, Array)
3050	if ( typeof qualifier !== "string" ) {
3051		return jQuery.grep( elements, function( elem ) {
3052			return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
3053		} );
3054	}
3055
3056	// Filtered directly for both simple and complex selectors
3057	return jQuery.filter( qualifier, elements, not );
3058}
3059
3060jQuery.filter = function( expr, elems, not ) {
3061	var elem = elems[ 0 ];
3062
3063	if ( not ) {
3064		expr = ":not(" + expr + ")";
3065	}
3066
3067	if ( elems.length === 1 && elem.nodeType === 1 ) {
3068		return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
3069	}
3070
3071	return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
3072		return elem.nodeType === 1;
3073	} ) );
3074};
3075
3076jQuery.fn.extend( {
3077	find: function( selector ) {
3078		var i, ret,
3079			len = this.length,
3080			self = this;
3081
3082		if ( typeof selector !== "string" ) {