http://noctuelles.info/js/pagetemplatefunctions.compile-min8e5e.js?v=15

143ict mode should be common
144// enough that all such attempts are guarded in a try block.
145"use strict";
146
147var arr = [];
148
149var getProto = Object.getPrototypeOf;
150
151var slice = arr.slice;
152
153var flat = arr.flat ? function( array ) {
154	return arr.flat.call( array );
155} : function( array ) {
156	return arr.concat.apply( [], array );
157};
158
159
160var push = arr.push;
161
162var indexOf = arr.indexOf;
163
164var class2type = {};
165
166var toString = class2type.toString;
167
168var hasOwn = class2type.hasOwnProperty;
169
170var fnToString = hasOwn.toString;
171
172var ObjectFunctionString = fnToString.call( Object );
173
174var support = {};
175
176var isFunction = function isFunction( obj ) {
177
178      // Support: Chrome <=57, Firefox <=52
179      // In some browsers, typeof returns "function" for HTML <object> elements
180      // (i.e., `typeof document.createElement( "object" ) === "function"`).
181      // We don't want to classify *any* DOM node as a function.
182      return typeof obj === "function" && typeof obj.nodeType !== "number";
183  };
184
185
186var isWindow = function isWindow( obj ) {
187		return obj != null && obj === obj.window;
188	};
189
190
191var document = window.document;
192
193
194
195	var preservedScriptAttributes = {
196		type: true,
197		src: true,
198		nonce: true,
199		noModule: true
200	};
201
202	function DOMEval( code, node, doc ) {
203		doc = doc || document;
204
205		var i, val,
206			script = doc.createElement( "script" );
207
208		script.text = code;
209		if ( node ) {
210			for ( i in preservedScriptAttributes ) {
211
212				// Support: Firefox 64+, Edge 18+
213				// Some browsers don't support the "nonce" property on scripts.
214				// On the other hand, just using `getAttribute` is not enough as
215				// the `nonce` attribute is reset to an empty string whenever it
216				// becomes browsing-context connected.
217				// See https://github.com/whatwg/html/issues/2369
218				// See https://html.spec.whatwg.org/#nonce-attributes
219				// The `node.getAttribute` check was added for the sake of
220				// `jQuery.globalEval` so that it can fake a nonce-containing node
221				// via an object.
222				val = node[ i ] || node.getAttribute && node.getAttribute( i );
223				if ( val ) {
224					script.setAttribute( i, val );
225				}
226			}
227		}
228		doc.head.appendChild( script ).parentNode.removeChild( script );
229	}
230
231
232function toType( obj ) {
233	if ( obj == null ) {
234		return obj + "";
235	}
236
237	// Support: Android <=2.3 only (functionish RegExp)
238	return typeof obj === "object" || typeof obj === "function" ?
239		class2type[ toString.call( obj ) ] || "object" :
240		typeof obj;
241}
242/* global Symbol */
243// Defining this global in .eslintrc.json would create a danger of using the global
244// unguarded in another place, it seems safer to define global only for this module
245
246
247
248var
249	version = "3.5.1",
250
251	// Define a local copy of jQuery
252	jQuery = function( selector, context ) {
253
254		// The jQuery object is actually just the init constructor 'enhanced'
255		// Need init if jQuery is called (just allow error to be thrown if not included)
256		return new jQuery.fn.init( selector, context );
257	};
258
259jQuery.fn = jQuery.prototype = {
260
261	// The current version of jQuery being used
262	jquery: version,
263
264	constructor: jQuery,
265
266	// The default length of a jQuery object is 0
267	length: 0,
268
269	toArray: function() {
270		return slice.call( this );
271	},
272
273	// Get the Nth element in the matched element set OR
274	// Get the whole matched element set as a clean array
275	get: function( num ) {
276
277		// Return all the elements in a clean array
278		if ( num == null ) {
279			return slice.call( this );
280		}
281
282		// Return just the one element from the set
283		return num < 0 ? this[ num + this.length ] : this[ num ];
284	},
285
286	// Take an array of elements and push it onto the stack
287	// (returning the new matched element set)
288	pushStack: function( elems ) {
289
290		// Build a new jQuery matched element set
291		var ret = jQuery.merge( this.constructor(), elems );
292
293		// Add the old object onto the stack (as a reference)
294		ret.prevObject = this;
295
296		// Return the newly-formed element set
297		return ret;
298	},
299
300	// Execute a callback for every element in the matched set.
301	each: function( callback ) {
302		return jQuery.each( this, callback );
303	},
304
305	map: function( callback ) {
306		return this.pushStack( jQuery.map( this, function( elem, i ) {
307			return callback.call( elem, i, elem );
308		} ) );
309	},
310
311	slice: function() {
312		return this.pushStack( slice.apply( this, arguments ) );
313	},
314
315	first: function() {
316		return this.eq( 0 );
317	},
318
319	last: function() {
320		return this.eq( -1 );
321	},
322
323	even: function() {
324		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
325			return ( i + 1 ) % 2;
326		} ) );
327	},
328
329	odd: function() {
330		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
331			return i % 2;
332		} ) );
333	},
334
335	eq: function( i ) {
336		var len = this.length,
337			j = +i + ( i < 0 ? len : 0 );
338		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
339	},
340
341	end: function() {
342		return this.prevObject || this.constructor();
343	},
344
345	// For internal use only.
346	// Behaves like an Array's method, not like a jQuery method.
347	push: push,
348	sort: arr.sort,
349	splice: arr.splice
350};
351
352jQuery.extend = jQuery.fn.extend = function() {
353	var options, name, src, copy, copyIsArray, clone,
354		target = arguments[ 0 ] || {},
355		i = 1,
356		length = arguments.length,
357		deep = false;

358
359	// Handle a deep copy situation
360	if ( typeof target === "boolean" ) {
361		deep = target;
362
363		// Skip the boolean and the target
364		target = arguments[ i ] || {};
365		i++;
366	}
367
368	// Handle case when target is a string or something (possible in deep copy)
369	if ( typeof target !== "object" && !isFunction( target ) ) {
370		target = {};
371	}
372
373	// Extend jQuery itself if only one argument is passed
374	if ( i === length ) {
375		target = this;
376		i--;
377	}
378
379	for ( ; i < length; i++ ) {
380
381		// Only deal with non-null/undefined values
382		if ( ( options = arguments[ i ] ) != null ) {
383
384			// Extend the base object
385			for ( name in options ) {
386				copy = options[ name ];
387
388				// Prevent Object.prototype pollution
389				// Prevent never-ending loop
390				if ( name === "__proto__" || target === copy ) {
391					continue;
392				}
393
394				// Recurse if we're merging plain objects or arrays
395				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
396					( copyIsArray = Array.isArray( copy ) ) ) ) {
397					src = target[ name ];
398
399					// Ensure proper type for the source value
400					if ( copyIsArray && !Array.isArray( src ) ) {
401						clone = [];
402					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
403						clone = {};
404					} else {
405						clone = src;
406					}
407					copyIsArray = false;
408
409					// Never move original objects, clone them
410					target[ name ] = jQuery.extend( deep, clone, copy );
411
412				// Don't bring in undefined values
413				} else if ( copy !== undefined ) {
414					target[ name ] = copy;
415				}
416			}
417		}
418	}
419
420	// Return the modified object
421	return target;
422};
423
424jQuery.extend( {
425
426	// Unique for each copy of jQuery on the page
427	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
428
429	// Assume jQuery is ready without the ready module
430	isReady: true,
431
432	error: function( msg ) {
433		throw new Error( msg );
434	},
435
436	noop: function() {},
437
438	isPlainObject: function( obj ) {
439		var proto, Ctor;
440
441		// Detect obvious negatives
442		// Use toString instead of jQuery.type to catch host objects
443		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
444			return false;
445		}
446
447		proto = getProto( obj );
448
449		// Objects with no prototype (e.g., `Object.create( null )`) are plain
450		if ( !proto ) {
451			return true;
452		}
453
454		// Objects with prototype are plain iff they were constructed by a global Object function
455		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
456		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
457	},
458
459	isEmptyObject: function( obj ) {
460		var name;
461
462		for ( name in obj ) {
463			return false;
464		}
465		return true;
466	},
467
468	// Evaluates a script in a provided context; falls back to the global one
469	// if not specified.
470	globalEval: function( code, options, doc ) {
471		DOMEval( code, { nonce: options && options.nonce }, doc );
472	},
473
474	each: function( obj, callback ) {
475		var length, i = 0;
476
477		if ( isArrayLike( obj ) ) {
478			length = obj.length;
479			for ( ; i < length; i++ ) {
480				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
481					break;
482				}
483			}
484		} else {
485			for ( i in obj ) {
486				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
487					break;
488				}
489			}
490		}
491
492		return obj;
493	},
494
495	// results is for internal usage only
496	makeArray: function( arr, results ) {
497		var ret = results || [];
498
499		if ( arr != null ) {
500			if ( isArrayLike( Object( arr ) ) ) {
501				jQuery.merge( ret,
502					typeof arr === "string" ?
503					[ arr ] : arr
504				);
505			} else {
506				push.call( ret, arr );
507			}
508		}
509
510		return ret;
511	},
512
513	inArray: function( elem, arr, i ) {
514		return arr == null ? -1 : indexOf.call( arr, elem, i );
515	},
516
517	// Support: Android <=4.0 only, PhantomJS 1 only
518	// push.apply(_, arraylike) throws on ancient WebKit
519	merge: function( first, second ) {
520		var len = +second.length,
521			j = 0,
522			i = first.length;
523
524		for ( ; j < len; j++ ) {
525			first[ i++ ] = second[ j ];
526		}
527
528		first.length = i;
529
530		return first;
531	},
532
533	grep: function( elems, callback, invert ) {
534		var callbackInverse,
535			matches = [],
536			i = 0,
537			length = elems.length,
538			callbackExpect = !invert;
539
540		// Go through the array, only saving the items
541		// that pass the validator function
542		for ( ; i < length; i++ ) {
543			callbackInverse = !callback( elems[ i ], i );
544			if ( callbackInverse !== callbackExpect ) {
545				matches.push( elems[ i ] );
546			}
547		}
548
549		return matches;
550	},
551
552	// arg is for internal usage only
553	map: function( elems, callback, arg ) {
554		var length, value,
555			i = 0,
556			ret = [];
557
558		// Go through the array, translating each of the items to their new values
559		if ( isArrayLike( elems ) ) {
560			length = elems.length;
561			for ( ; i < length; i++ ) {
562				value = callback( elems[ i ], i, arg );
563
564				if ( value != null ) {

565					ret.push( value );
566				}
567			}
568
569		// Go through every key on the object,
570		} else {
571			for ( i in elems ) {
572				value = callback( elems[ i ], i, arg );
573
574				if ( value != null ) {
575					ret.push( value );
576				}
577			}
578		}
579
580		// Flatten any nested arrays
581		return flat( ret );
582	},
583
584	// A global GUID counter for objects
585	guid: 1,
586
587	// jQuery.support is not used in Core but other projects attach their
588	// properties to it so it needs to exist.
589	support: support
590} );
591
592if ( typeof Symbol === "function" ) {
593	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
594}
595
596// Populate the class2type map
597jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
598function( _i, name ) {
599	class2type[ "[object " + name + "]" ] = name.toLowerCase();
600} );
601
602function isArrayLike( obj ) {
603
604	// Support: real iOS 8.2 only (not reproducible in simulator)
605	// `in` check used to prevent JIT error (gh-2145)
606	// hasOwn isn't used here due to false negatives
607	// regarding Nodelist length in IE
608	var length = !!obj && "length" in obj && obj.length,
609		type = toType( obj );
610
611	if ( isFunction( obj ) || isWindow( obj ) ) {
612		return false;
613	}
614
615	return type === "array" || length === 0 ||
616		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
617}
618var Sizzle =
619/*!
620 * Sizzle CSS Selector Engine v2.3.5
621 * https://sizzlejs.com/
622 *
623 * Copyright JS Foundation and other contributors
624 * Released under the MIT license
625 * https://js.foundation/
626 *
627 * Date: 2020-03-14

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

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