https://wxuas.com/js/domain-map-webpack.js?v=6MM1xIE0HGpzr2DULxbupDz1XTOdDrJhZjXxHvMP5TY

4
5/***/ (function(module, exports) {
6
7var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
8 * jQuery JavaScript Library v3.6.1
9 * https://jquery.com/
10 *
11 * Includes Sizzle.js
12 * https://sizzlejs.com/
13 *
14 * Copyright OpenJS Foundation and other contributors
15 * Released under the MIT license
16 * https://jquery.org/license
17 *
18 * Date: 2022-08-26T17:52Z
19 */
20( function( global, factory ) {
21
22	"use strict";
23
24	if (  true && typeof module.exports === "object" ) {
25
26		// For CommonJS and CommonJS-like environments where a proper `window`
27		// is present, execute the factory and get jQuery.
28		// For environments that do not have a `window` with a `document`
29		// (such as Node.js), expose a factory as module.exports.
30		// This accentuates the need for the creation of a real `window`.
31		// e.g. var jQuery = require("jquery")(window);
32		// See ticket trac-14549 for more info.
33		module.exports = global.document ?
34			factory( global, true ) :
35			function( w ) {
36				if ( !w.document ) {
37					throw new Error( "jQuery requires a window with a document" );
38				}
39				return factory( w );
40			};
41	} else {
42		factory( global );
43	}
44
45// Pass this if window is not defined yet
46} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
47
48// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
49// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
50// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
51// enough that all such attempts are guarded in a try block.
52"use strict";
53
54var arr = [];
55
56var getProto = Object.getPrototypeOf;
57
58var slice = arr.slice;
59
60var flat = arr.flat ? function( array ) {
61	return arr.flat.call( array );
62} : function( array ) {
63	return arr.concat.apply( [], array );
64};
65
66
67var push = arr.push;
68
69var indexOf = arr.indexOf;
70
71var class2type = {};
72
73var toString = class2type.toString;
74
75var hasOwn = class2type.hasOwnProperty;
76
77var fnToString = hasOwn.toString;
78
79var ObjectFunctionString = fnToString.call( Object );
80
81var support = {};
82
83var isFunction = function isFunction( obj ) {
84
85		// Support: Chrome <=57, Firefox <=52
86		// In some browsers, typeof returns "function" for HTML <object> elements
87		// (i.e., `typeof document.createElement( "object" ) === "function"`).
88		// We don't want to classify *any* DOM node as a function.
89		// Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5
90		// Plus for old WebKit, typeof returns "function" for HTML collections
91		// (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756)
92		return typeof obj === "function" && typeof obj.nodeType !== "number" &&
93			typeof obj.item !== "function";
94	};
95
96
97var isWindow = function isWindow( obj ) {
98		return obj != null && obj === obj.window;
99	};
100
101
102var document = window.document;
103
104
105
106	var preservedScriptAttributes = {
107		type: true,
108		src: true,
109		nonce: true,
110		noModule: true
111	};
112
113	function DOMEval( code, node, doc ) {
114		doc = doc || document;
115
116		var i, val,
117			script = doc.createElement( "script" );
118
119		script.text = code;
120		if ( node ) {
121			for ( i in preservedScriptAttributes ) {
122
123				// Support: Firefox 64+, Edge 18+
124				// Some browsers don't support the "nonce" property on scripts.
125				// On the other hand, just using `getAttribute` is not enough as
126				// the `nonce` attribute is reset to an empty string whenever it
127				// becomes browsing-context connected.
128				// See https://github.com/whatwg/html/issues/2369
129				// See https://html.spec.whatwg.org/#nonce-attributes
130				// The `node.getAttribute` check was added for the sake of
131				// `jQuery.globalEval` so that it can fake a nonce-containing node
132				// via an object.
133				val = node[ i ] || node.getAttribute && node.getAttribute( i );
134				if ( val ) {
135					script.setAttribute( i, val );
136				}
137			}
138		}
139		doc.head.appendChild( script ).parentNode.removeChild( script );
140	}
141
142
143function toType( obj ) {
144	if ( obj == null ) {
145		return obj + "";
146	}
147
148	// Support: Android <=2.3 only (functionish RegExp)
149	return typeof obj === "object" || typeof obj === "function" ?
150		class2type[ toString.call( obj ) ] || "object" :
151		typeof obj;
152}
153/* global Symbol */
154// Defining this global in .eslintrc.json would create a danger of using the global
155// unguarded in another place, it seems safer to define global only for this module
156
157
158
159var
160	version = "3.6.1",
161
162	// Define a local copy of jQuery
163	jQuery = function( selector, context ) {
164
165		// The jQuery object is actually just the init constructor 'enhanced'
166		// Need init if jQuery is called (just allow error to be thrown if not included)
167		return new jQuery.fn.init( selector, context );
168	};
169
170jQuery.fn = jQuery.prototype = {
171
172	// The current version of jQuery being used
173	jquery: version,
174
175	constructor: jQuery,
176
177	// The default length of a jQuery object is 0
178	length: 0,
179
180	toArray: function() {
181		return slice.call( this );
182	},
183
184	// Get the Nth element in the matched element set OR
185	// Get the whole matched element set as a clean array
186	get: function( num ) {
187
188		// Return all the elements in a clean array
189		if ( num == null ) {
190			return slice.call( this );
191		}
192
193		// Return just the one element from the set
194		return num < 0 ? this[ num + this.length ] : this[ num ];
195	},
196
197	// Take an array of elements and push it onto the stack
198	// (returning the new matched element set)
199	pushStack: function( elems ) {
200
201		// Build a new jQuery matched element set
202		var ret = jQuery.merge( this.constructor(), elems );
203
204		// Add the old object onto the stack (as a reference)
205		ret.prevObject = this;
206
207		// Return the newly-formed element set
208		return ret;
209	},
210
211	// Execute a callback for every element in the matched set.
212	each: function( callback ) {
213		return jQuery.each( this, callback );
214	},
215
216	map: function( callback ) {
217		return this.pushStack( jQuery.map( this, function( elem, i ) {
218			return callback.call( elem, i, elem );
219		} ) );
220	},
221
222	slice: function() {
223		return this.pushStack( slice.apply( this, arguments ) );
224	},
225
226	first: function() {
227		return this.eq( 0 );
228	},
229
230	last: function() {
231		return this.eq( -1 );
232	},
233
234	even: function() {
235		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
236			return ( i + 1 ) % 2;
237		} ) );
238	},
239
240	odd: function() {
241		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
242			return i % 2;
243		} ) );
244	},
245
246	eq: function( i ) {
247		var len = this.length,
248			j = +i + ( i < 0 ? len : 0 );
249		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
250	},
251
252	end: function() {
253		return this.prevObject || this.constructor();
254	},
255
256	// For internal use only.
257	// Behaves like an Array's method, not like a jQuery method.
258	push: push,
259	sort: arr.sort,
260	splice: arr.splice
261};
262
263jQuery.extend = jQuery.fn.extend = function() {
264	var options, name, src, copy, copyIsArray, clone,
265		target = arguments[ 0 ] || {},
266		i = 1,
267		length = arguments.length,
268		deep = false;

269
270	// Handle a deep copy situation
271	if ( typeof target === "boolean" ) {
272		deep = target;
273
274		// Skip the boolean and the target
275		target = arguments[ i ] || {};
276		i++;
277	}
278
279	// Handle case when target is a string or something (possible in deep copy)
280	if ( typeof target !== "object" && !isFunction( target ) ) {
281		target = {};
282	}
283
284	// Extend jQuery itself if only one argument is passed
285	if ( i === length ) {
286		target = this;
287		i--;
288	}
289
290	for ( ; i < length; i++ ) {
291
292		// Only deal with non-null/undefined values
293		if ( ( options = arguments[ i ] ) != null ) {
294
295			// Extend the base object
296			for ( name in options ) {
297				copy = options[ name ];
298
299				// Prevent Object.prototype pollution
300				// Prevent never-ending loop
301				if ( name === "__proto__" || target === copy ) {
302					continue;
303				}
304
305				// Recurse if we're merging plain objects or arrays
306				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
307					( copyIsArray = Array.isArray( copy ) ) ) ) {
308					src = target[ name ];
309
310					// Ensure proper type for the source value
311					if ( copyIsArray && !Array.isArray( src ) ) {
312						clone = [];
313					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
314						clone = {};
315					} else {
316						clone = src;
317					}
318					copyIsArray = false;
319
320					// Never move original objects, clone them
321					target[ name ] = jQuery.extend( deep, clone, copy );
322
323				// Don't bring in undefined values
324				} else if ( copy !== undefined ) {
325					target[ name ] = copy;
326				}
327			}
328		}
329	}
330
331	// Return the modified object
332	return target;
333};
334
335jQuery.extend( {
336
337	// Unique for each copy of jQuery on the page
338	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
339
340	// Assume jQuery is ready without the ready module
341	isReady: true,
342
343	error: function( msg ) {
344		throw new Error( msg );
345	},
346
347	noop: function() {},
348
349	isPlainObject: function( obj ) {
350		var proto, Ctor;
351
352		// Detect obvious negatives
353		// Use toString instead of jQuery.type to catch host objects
354		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
355			return false;
356		}
357
358		proto = getProto( obj );
359
360		// Objects with no prototype (e.g., `Object.create( null )`) are plain
361		if ( !proto ) {
362			return true;
363		}
364
365		// Objects with prototype are plain iff they were constructed by a global Object function
366		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
367		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
368	},
369
370	isEmptyObject: function( obj ) {
371		var name;
372
373		for ( name in obj ) {
374			return false;
375		}
376		return true;
377	},
378
379	// Evaluates a script in a provided context; falls back to the global one
380	// if not specified.
381	globalEval: function( code, options, doc ) {
382		DOMEval( code, { nonce: options && options.nonce }, doc );
383	},
384
385	each: function( obj, callback ) {
386		var length, i = 0;
387
388		if ( isArrayLike( obj ) ) {
389			length = obj.length;
390			for ( ; i < length; i++ ) {
391				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
392					break;
393				}
394			}
395		} else {
396			for ( i in obj ) {
397				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
398					break;
399				}
400			}
401		}
402
403		return obj;
404	},
405
406	// results is for internal usage only
407	makeArray: function( arr, results ) {
408		var ret = results || [];
409
410		if ( arr != null ) {
411			if ( isArrayLike( Object( arr ) ) ) {
412				jQuery.merge( ret,
413					typeof arr === "string" ?
414						[ arr ] : arr
415				);
416			} else {
417				push.call( ret, arr );
418			}
419		}
420
421		return ret;
422	},
423
424	inArray: function( elem, arr, i ) {
425		return arr == null ? -1 : indexOf.call( arr, elem, i );
426	},
427
428	// Support: Android <=4.0 only, PhantomJS 1 only
429	// push.apply(_, arraylike) throws on ancient WebKit
430	merge: function( first, second ) {
431		var len = +second.length,
432			j = 0,
433			i = first.length;
434
435		for ( ; j < len; j++ ) {
436			first[ i++ ] = second[ j ];
437		}
438
439		first.length = i;
440
441		return first;
442	},
443
444	grep: function( elems, callback, invert ) {
445		var callbackInverse,
446			matches = [],
447			i = 0,
448			length = elems.length,
449			callbackExpect = !invert;
450
451		// Go through the array, only saving the items
452		// that pass the validator function
453		for ( ; i < length; i++ ) {
454			callbackInverse = !callback( elems[ i ], i );
455			if ( callbackInverse !== callbackExpect ) {
456				matches.push( elems[ i ] );
457			}
458		}
459
460		return matches;
461	},
462
463	// arg is for internal usage only
464	map: function( elems, callback, arg ) {
465		var length, value,
466			i = 0,
467			ret = [];
468
469		// Go through the array, translating each of the items to their new values
470		if ( isArrayLike( elems ) ) {
471			length = elems.length;
472			for ( ; i < length; i++ ) {
473				value = callback( elems[ i ], i, arg );
474
475				if ( value != null ) {
476					ret.push( value );
477				}
478			}
479
480		// Go through every key on the object,
481		} else {
482			for ( i in elems ) {
483				value = callback( elems[ i ], i, arg );
484
485				if ( value != null ) {
486					ret.push( value );
487				}
488			}
489		}
490
491		// Flatten any nested arrays
492		return flat( ret );
493	},
494
495	// A global GUID counter for objects
496	guid: 1,
497
498	// jQuery.support is not used in Core but other projects attach their
499	// properties to it so it needs to exist.
500	support: support
501} );
502
503if ( typeof Symbol === "function" ) {
504	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
505}
506
507// Populate the class2type map
508jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
509	function( _i, name ) {
510		class2type[ "[object " + name + "]" ] = name.toLowerCase();
511	} );
512
513function isArrayLike( obj ) {
514
515	// Support: real iOS 8.2 only (not reproducible in simulator)
516	// `in` check used to prevent JIT error (gh-2145)
517	// hasOwn isn't used here due to false negatives
518	// regarding Nodelist length in IE
519	var length = !!obj && "length" in obj && obj.length,
520		type = toType( obj );
521
522	if ( isFunction( obj ) || isWindow( obj ) ) {
523		return false;
524	}
525
526	return type === "array" || length === 0 ||
527		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
528}
529var Sizzle =
530/*!
531 * Sizzle CSS Selector Engine v2.3.6
532 * https://sizzlejs.com/
533 *
534 * Copyright JS Foundation and other contributors
535 * Released under the MIT license
536 * https://js.foundation/
537 *
538 * Date: 2021-02-16
539 */
540( function( window ) {
541var i,
542	support,
543	Expr,
544	getText,
545	isXML,
546	tokenize,
547	compile,
548	select,
549	outermostContext,
550	sortInput,
551	hasDuplicate,
552
553	// Local document vars
554	setDocument,
555	document,
556	docElem,
557	documentIsHTML,
558	rbuggyQSA,
559	rbuggyMatches,
560	matches,
561	contains,
562
563	// Instance-specific data
564	expando = "sizzle" + 1 * new Date(),
565	preferredDoc = window.document,
566	dirruns = 0,
567	done = 0,
568	classCache = createCache(),
569	tokenCache = createCache(),
570	compilerCache = createCache(),
571	nonnativeSelectorCache = createCache(),
572	sortOrder = function( a, b ) {
573		if ( a === b ) {
574			hasDuplicate = true;
575		}
576		return 0;
577	},
578
579	// Instance methods
580	hasOwn = ( {} ).hasOwnProperty,
581	arr = [],
582	pop = arr.pop,
583	pushNative = arr.push,
584	push = arr.push,
585	slice = arr.slice,
586
587	// Use a stripped-down indexOf as it's faster than native
588	// https://jsperf.com/thor-indexof-vs-for/5
589	indexOf = function( list, elem ) {
590		var i = 0,
591			len = list.length;
592		for ( ; i < len; i++ ) {
593			if ( list[ i ] === elem ) {
594				return i;
595			}
596		}
597		return -1;
598	},
599
600	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
601		"ismap|loop|multiple|open|readonly|required|scoped",
602
603	// Regular expressions
604
605	// http://www.w3.org/TR/css3-selectors/#whitespace
606	whitespace = "[\\x20\\t\\r\\n\\f]",
607
608	// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
609	identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
610		"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
611
612	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
613	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
614
615		// Operator (capture 2)
616		"*([*^$|!~]?=)" + whitespace +
617
618		// "Attribute values must be CSS identifiers [capture 5]
619		// or strings [capture 3 or capture 4]"
620		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
621		whitespace + "*\\]",
622
623	pseudos = ":(" + identifier + ")(?:\\((" +
624
625		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
626		// 1. quoted (capture 3; capture 4 or capture 5)
627		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
628
629		// 2. simple (capture 6)
630		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
631
632		// 3. anything else (capture 2)
633		".*" +
634		")\\)|)",
635
636	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
637	rwhitespace = new RegExp( whitespace + "+", "g" ),
638	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
639		whitespace + "+$", "g" ),
640
641	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
642	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
643		"*" ),
644	rdescend = new RegExp( whitespace + "|>" ),
645
646	rpseudo = new RegExp( pseudos ),
647	ridentifier = new RegExp( "^" + identifier + "$" ),
648
649	matchExpr = {
650		"ID": new RegExp( "^#(" + identifier + ")" ),
651		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
652		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
653		"ATTR": new RegExp( "^" + attributes ),
654		"PSEUDO": new RegExp( "^" + pseudos ),
655		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
656			whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
657			whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
658		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
659
660		// For use in libraries implementing .is()
661		// We use this for POS matching in `select`
662		"needsContext": new RegExp( "^" + whitespace +
663			"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
664			"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
665	},
666
667	rhtml = /HTML$/i,
668	rinputs = /^(?:input|select|textarea|button)$/i,
669	rheader = /^h\d$/i,
670
671	rnative = /^[^{]+\{\s*\[native \w/,
672
673	// Easily-parseable/retrievable ID or TAG or CLASS selectors
674	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
675
676	rsibling = /[+~]/,
677
678	// CSS escapes
679	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
680	runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
681	funescape = function( escape, nonHex ) {
682		var high = "0x" + escape.slice( 1 ) - 0x10000;
683
684		return nonHex ?
685
686			// Strip the backslash prefix from a non-hex escape sequence
687			nonHex :
688
689			// Replace a hexadecimal escape sequence with the encoded Unicode code point
690			// Support: IE <=11+
691			// For values outside the Basic Multilingual Plane (BMP), manually construct a
692			// surrogate pair
693			high < 0 ?
694				String.fromCharCode( high + 0x10000 ) :
695				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
696	},
697
698	// CSS string/identifier serialization
699	// https://drafts.csswg.org/cssom/#common-serializing-idioms
700	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
701	fcssescape = function( ch, asCodePoint ) {
702		if ( asCodePoint ) {
703
704			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
705			if ( ch === "\0" ) {
706				return "\uFFFD";
707			}
708
709			// Control characters and (dependent upon position) numbers get escaped as code points
710			return ch.slice( 0, -1 ) + "\\" +
711				ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
712		}
713
714		// Other potentially-special ASCII characters get backslash-escaped
715		return "\\" + ch;
716	},
717
718	// Used for iframes
719	// See setDocument()
720	// Removing the function wrapper causes a "Permission Denied"
721	// error in IE
722	unloadHandler = function() {
723		setDocument();
724	},
725
726	inDisabledFieldset = addCombinator(
727		function( elem ) {
728			return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
729		},
730		{ dir: "parentNode", next: "legend" }
731	);
732
733// Optimize for push.apply( _, NodeList )
734try {
735	push.apply(
736		( arr = slice.call( preferredDoc.childNodes ) ),
737		preferredDoc.childNodes
738	);
739
740	// Support: Android<4.0
741	// Detect silently failing push.apply
742	// eslint-disable-next-line no-unused-expressions
743	arr[ preferredDoc.childNodes.length ].nodeType;
744} catch ( e ) {
745	push = { apply: arr.length ?
746
747		// Leverage slice if possible
748		function( target, els ) {
749			pushNative.apply( target, slice.call( els ) );
750		} :
751
752		// Support: IE<9
753		// Otherwise append directly
754		function( target, els ) {
755			var j = target.length,
756				i = 0;
757
758			// Can't trust NodeList.length
759			while ( ( target[ j++ ] = els[ i++ ] ) ) {}
760			target.length = j - 1;
761		}
762	};
763}
764
765function Sizzle( selector, context, results, seed ) {
766	var m, i, elem, nid, match, groups, newSelector,
767		newContext = context && context.ownerDocument,
768
769		// nodeType defaults to 9, since context defaults to document
770		nodeType = context ? context.nodeType : 9;
771
772	results = results || [];
773
774	// Return early from calls with invalid selector or context
775	if ( typeof selector !== "string" || !selector ||
776		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
777
778		return results;
779	}
780
781	// Try to shortcut find operations (as opposed to filters) in HTML documents
782	if ( !seed ) {
783		setDocument( context );
784		context = context || document;
785
786		if ( documentIsHTML ) {
787
788			// If the selector is sufficiently simple, try using a "get*By*" DOM method
789			// (excepting DocumentFragment context, where the methods don't exist)
790			if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
791
792				// ID selector
793				if ( ( m = match[ 1 ] ) ) {
794
795					// Document context
796					if ( nodeType === 9 ) {
797						if ( ( elem = context.getElementById( m ) ) ) {
798
799							// Support: IE, Opera, Webkit
800							// TODO: identify versions
801							// getElementById can match elements by name instead of ID
802							if ( elem.id === m ) {
803								results.push( elem );
804								return results;
805							}
806						} else {
807							return results;
808						}
809
810					// Element context
811					} else {
812
813						// Support: IE, Opera, Webkit
814						// TODO: identify versions
815						// getElementById can match elements by name instead of ID
816						if ( newContext && ( elem = newContext.getElementById( m ) ) &&
817							contains( context, elem ) &&
818							elem.id === m ) {
819
820							results.push( elem );
821							return results;
822						}
823					}
824
825				// Type selector
826				} else if ( match[ 2 ] ) {
827					push.apply( results, context.getElementsByTagName( selector ) );
828					return results;
829
830				// Class selector
831				} else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&
832					context.getElementsByClassName ) {
833
834					push.apply( results, context.getElementsByClassName( m ) );
835					return results;
836				}
837			}
838
839			// Take advantage of querySelectorAll
840			if ( support.qsa &&
841				!nonnativeSelectorCache[ selector + " " ] &&
842				( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&
843
844				// Support: IE 8 only
845				// Exclude object elements
846				( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) {
847
848				newSelector = selector;
849				newContext = context;
850
851				// qSA considers elements outside a scoping root when evaluating child or
852				// descendant combinators, which is not what we want.
853				// In such cases, we work around the behavior by prefixing every selector in the
854				// list with an ID selector referencing the scope context.
855				// The technique has to be used as well when a leading combinator is used
856				// as such selectors are not recognized by querySelectorAll.
857				// Thanks to Andrew Dupont for this technique.
858				if ( nodeType === 1 &&
859					( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
860
861					// Expand context for sibling selectors
862					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
863						context;
864
865					// We can use :scope instead of the ID hack if the browser
866					// supports it & if we're not changing the context.
867					if ( newContext !== context || !support.scope ) {
868
869						// Capture the context ID, setting it first if necessary
870						if ( ( nid = context.getAttribute( "id" ) ) ) {
871							nid = nid.replace( rcssescape, fcssescape );
872						} else {
873							context.setAttribute( "id", ( nid = expando ) );
874						}
875					}
876
877					// Prefix every selector in the list
878					groups = tokenize( selector );
879					i = groups.length;
880					while ( i-- ) {
881						groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
882							toSelector( groups[ i ] );
883					}
884					newSelector = groups.join( "," );
885				}
886
887				try {
888					push.apply( results,
889						newContext.querySelectorAll( newSelector )
890					);
891					return results;
892				} catch ( qsaError ) {
893					nonnativeSelectorCache( selector, true );
894				} finally {
895					if ( nid === expando ) {
896						context.removeAttribute( "id" );
897					}
898				}
899			}
900		}
901	}
902
903	// All others
904	return select( selector.replace( rtrim, "$1" ), context, results, seed );
905}
906
907/**
908 * Create key-value caches of limited size
909 * @returns {function(string, object)} Returns the Object data after storing it on itself with
910 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
911 *	deleting the oldest entry
912 */
913function createCache() {
914	var keys = [];
915
916	function cache( key, value ) {
917
918		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
919		if ( keys.push( key + " " ) > Expr.cacheLength ) {
920
921			// Only keep the most recent entries
922			delete cache[ keys.shift() ];
923		}
924		return ( cache[ key + " " ] = value );
925	}
926	return cache;
927}
928
929/**
930 * Mark a function for special use by Sizzle
931 * @param {Function} fn The function to mark
932 */
933function markFunction( fn ) {
934	fn[ expando ] = true;
935	return fn;
936}
937
938/**
939 * Support testing using an element
940 * @param {Function} fn Passed the created element and returns a boolean result
941 */
942function assert( fn ) {
943	var el = document.createElement( "fieldset" );
944
945	try {
946		return !!fn( el );
947	} catch ( e ) {
948		return false;
949	} finally {
950
951		// Remove from its parent by default
952		if ( el.parentNode ) {
953			el.parentNode.removeChild( el );
954		}
955
956		// release memory in IE
957		el = null;
958	}
959}
960
961/**
962 * Adds the same handler for all of the specified attrs
963 * @param {String} attrs Pipe-separated list of attributes
964 * @param {Function} handler The method that will be applied
965 */
966function addHandle( attrs, handler ) {
967	var arr = attrs.split( "|" ),
968		i = arr.length;
969
970	while ( i-- ) {
971		Expr.attrHandle[ arr[ i ] ] = handler;
972	}
973}
974
975/**
976 * Checks document order of two siblings
977 * @param {Element} a
978 * @param {Element} b
979 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
980 */
981function siblingCheck( a, b ) {
982	var cur = b && a,
983		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
984			a.sourceIndex - b.sourceIndex;
985
986	// Use IE sourceIndex if available on both nodes
987	if ( diff ) {
988		return diff;
989	}
990
991	// Check if b follows a
992	if ( cur ) {
993		while ( ( cur = cur.nextSibling ) ) {
994			if ( cur === b ) {
995				return -1;
996			}
997		}
998	}
999
1000	return a ? 1 : -1;
1001}
1002
1003/**
1004 * Returns a function to use in pseudos for input types
1005 * @param {String} type
1006 */
1007function createInputPseudo( type ) {
1008	return function( elem ) {
1009		var name = elem.nodeName.toLowerCase();
1010		return name === "input" && elem.type === type;
1011	};
1012}
1013
1014/**
1015 * Returns a function to use in pseudos for buttons
1016 * @param {String} type
1017 */
1018function createButtonPseudo( type ) {
1019	return function( elem ) {
1020		var name = elem.nodeName.toLowerCase();
1021		return ( name === "input" || name === "button" ) && elem.type === type;
1022	};
1023}
1024
1025/**
1026 * Returns a function to use in pseudos for :enabled/:disabled
1027 * @param {Boolean} disabled true for :disabled; false for :enabled
1028 */
1029function createDisabledPseudo( disabled ) {
1030
1031	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1032	return function( elem ) {
1033
1034		// Only certain elements can match :enabled or :disabled
1035		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1036		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1037		if ( "form" in elem ) {
1038
1039			// Check for inherited disabledness on relevant non-disabled elements:
1040			// * listed form-associated elements in a disabled fieldset
1041			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
1042			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1043			// * option elements in a disabled optgroup
1044			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1045			// All such elements have a "form" property.
1046			if ( elem.parentNode && elem.disabled === false ) {
1047
1048				// Option elements defer to a parent optgroup if present
1049				if ( "label" in elem ) {
1050					if ( "label" in elem.parentNode ) {
1051						return elem.parentNode.disabled === disabled;
1052					} else {
1053						return elem.disabled === disabled;
1054					}
1055				}
1056
1057				// Support: IE 6 - 11
1058				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
1059				return elem.isDisabled === disabled ||
1060
1061					// Where there is no isDisabled, check manually
1062					/* jshint -W018 */
1063					elem.isDisabled !== !disabled &&
1064					inDisabledFieldset( elem ) === disabled;
1065			}
1066
1067			return elem.disabled === disabled;
1068
1069		// Try to winnow out elements that can't be disabled before trusting the disabled property.
1070		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1071		// even exist on them, let alone have a boolean value.
1072		} else if ( "label" in elem ) {
1073			return elem.disabled === disabled;
1074		}
1075
1076		// Remaining elements are neither :enabled nor :disabled
1077		return false;
1078	};
1079}
1080
1081/**
1082 * Returns a function to use in pseudos for positionals
1083 * @param {Function} fn
1084 */
1085function createPositionalPseudo( fn ) {
1086	return markFunction( function( argument ) {
1087		argument = +argument;
1088		return markFunction( function( seed, matches ) {
1089			var j,
1090				matchIndexes = fn( [], seed.length, argument ),
1091				i = matchIndexes.length;
1092
1093			// Match elements found at the specified indexes
1094			while ( i-- ) {
1095				if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
1096					seed[ j ] = !( matches[ j ] = seed[ j ] );
1097				}
1098			}
1099		} );
1100	} );
1101}
1102
1103/**
1104 * Checks a node for validity as a Sizzle context
1105 * @param {Element|Object=} context
1106 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1107 */
1108function testContext( context ) {
1109	return context && typeof context.getElementsByTagName !== "undefined" && context;
1110}
1111
1112// Expose support vars for convenience
1113support = Sizzle.support = {};
1114
1115/**
1116 * Detects XML nodes
1117 * @param {Element|Object} elem An element or a document
1118 * @returns {Boolean} True iff elem is a non-HTML XML node
1119 */
1120isXML = Sizzle.isXML = function( elem ) {
1121	var namespace = elem && elem.namespaceURI,
1122		docElem = elem && ( elem.ownerDocument || elem ).documentElement;
1123
1124	// Support: IE <=8
1125	// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
1126	// https://bugs.jquery.com/ticket/4833
1127	return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
1128};
1129
1130/**
1131 * Sets document-related variables once based on the current document
1132 * @param {Element|Object} [doc] An element or document object to use to set the document
1133 * @returns {Object} Returns the current document
1134 */
1135setDocument = Sizzle.setDocument = function( node ) {
1136	var hasCompare, subWindow,
1137		doc = node ? node.ownerDocument || node : preferredDoc;
1138
1139	// Return early if doc is invalid or already selected
1140	// Support: IE 11+, Edge 17 - 18+
1141	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1142	// two documents; shallow comparisons work.
1143	// eslint-disable-next-line eqeqeq
1144	if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
1145		return document;
1146	}
1147
1148	// Update global variables
1149	document = doc;
1150	docElem = document.documentElement;
1151	documentIsHTML = !isXML( document );
1152
1153	// Support: IE 9 - 11+, Edge 12 - 18+
1154	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1155	// Support: IE 11+, Edge 17 - 18+
1156	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1157	// two documents; shallow comparisons work.
1158	// eslint-disable-next-line eqeqeq
1159	if ( preferredDoc != document &&
1160		( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
1161
1162		// Support: IE 11, Edge
1163		if ( subWindow.addEventListener ) {
1164			subWindow.addEventListener( "unload", unloadHandler, false );
1165
1166		// Support: IE 9 - 10 only
1167		} else if ( subWindow.attachEvent ) {
1168			subWindow.attachEvent( "onunload", unloadHandler );
1169		}
1170	}
1171
1172	// Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,
1173	// Safari 4 - 5 only, Opera <=11.6 - 12.x only
1174	// IE/Edge & older browsers don't support the :scope pseudo-class.
1175	// Support: Safari 6.0 only
1176	// Safari 6.0 supports :scope but it's an alias of :root there.
1177	support.scope = assert( function( el ) {
1178		docElem.appendChild( el ).appendChild( document.createElement( "div" ) );
1179		return typeof el.querySelectorAll !== "undefined" &&
1180			!el.querySelectorAll( ":scope fieldset div" ).length;
1181	} );
1182
1183	/* Attributes
1184	---------------------------------------------------------------------- */
1185
1186	// Support: IE<8
1187	// Verify that getAttribute really returns attributes and not properties
1188	// (excepting IE8 booleans)
1189	support.attributes = assert( function( el ) {
1190		el.className = "i";
1191		return !el.getAttribute( "className" );
1192	} );
1193
1194	/* getElement(s)By*
1195	---------------------------------------------------------------------- */
1196
1197	// Check if getElementsByTagName("*") returns only elements
1198	support.getElementsByTagName = assert( function( el ) {
1199		el.appendChild( document.createComment( "" ) );
1200		return !el.getElementsByTagName( "*" ).length;
1201	} );
1202
1203	// Support: IE<9
1204	support.getElementsByClassName = rnative.test( document.getElementsByClassName );
1205
1206	// Support: IE<10
1207	// Check if getElementById returns elements by name
1208	// The broken getElementById methods don't pick up programmatically-set names,
1209	// so use a roundabout getElementsByName test
1210	support.getById = assert( function( el ) {
1211		docElem.appendChild( el ).id = expando;
1212		return !document.getElementsByName || !document.getElementsByName( expando ).length;
1213	} );
1214
1215	// ID filter and find
1216	if ( support.getById ) {
1217		Expr.filter[ "ID" ] = function( id ) {
1218			var attrId = id.replace( runescape, funescape );
1219			return function( elem ) {
1220				return elem.getAttribute( "id" ) === attrId;
1221			};
1222		};
1223		Expr.find[ "ID" ] = function( id, context ) {
1224			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1225				var elem = context.getElementById( id );
1226				return elem ? [ elem ] : [];
1227			}
1228		};
1229	} else {
1230		Expr.filter[ "ID" ] =  function( id ) {
1231			var attrId = id.replace( runescape, funescape );
1232			return function( elem ) {
1233				var node = typeof elem.getAttributeNode !== "undefined" &&
1234					elem.getAttributeNode( "id" );
1235				return node && node.value === attrId;
1236			};
1237		};
1238
1239		// Support: IE 6 - 7 only
1240		// getElementById is not reliable as a find shortcut
1241		Expr.find[ "ID" ] = function( id, context ) {
1242			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1243				var node, i, elems,
1244					elem = context.getElementById( id );
1245
1246				if ( elem ) {
1247
1248					// Verify the id attribute
1249					node = elem.getAttributeNode( "id" );
1250					if ( node && node.value === id ) {
1251						return [ elem ];
1252					}
1253
1254					// Fall back on getElementsByName
1255					elems = context.getElementsByName( id );
1256					i = 0;
1257					while ( ( elem = elems[ i++ ] ) ) {
1258						node = elem.getAttributeNode( "id" );
1259						if ( node && node.value === id ) {
1260							return [ elem ];
1261						}
1262					}
1263				}
1264
1265				return [];
1266			}
1267		};
1268	}
1269
1270	// Tag
1271	Expr.find[ "TAG" ] = support.getElementsByTagName ?
1272		function( tag, context ) {
1273			if ( typeof context.getElementsByTagName !== "undefined" ) {
1274				return context.getElementsByTagName( tag );
1275
1276			// DocumentFragment nodes don't have gEBTN
1277			} else if ( support.qsa ) {
1278				return context.querySelectorAll( tag );
1279			}
1280		} :
1281
1282		function( tag, context ) {
1283			var elem,
1284				tmp = [],
1285				i = 0,
1286
1287				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1288				results = context.getElementsByTagName( tag );
1289
1290			// Filter out possible comments
1291			if ( tag === "*" ) {
1292				while ( ( elem = results[ i++ ] ) ) {
1293					if ( elem.nodeType === 1 ) {
1294						tmp.push( elem );
1295					}
1296				}
1297
1298				return tmp;
1299			}
1300			return results;
1301		};
1302
1303	// Class
1304	Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) {
1305		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1306			return context.getElementsByClassName( className );
1307		}
1308	};
1309
1310	/* QSA/matchesSelector
1311	---------------------------------------------------------------------- */
1312
1313	// QSA and matchesSelector support
1314
1315	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1316	rbuggyMatches = [];
1317
1318	// qSa(:focus) reports false when true (Chrome 21)
1319	// We allow this because of a bug in IE8/9 that throws an error
1320	// whenever `document.activeElement` is accessed on an iframe
1321	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1322	// See https://bugs.jquery.com/ticket/13378
1323	rbuggyQSA = [];
1324
1325	if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {
1326
1327		// Build QSA regex
1328		// Regex strategy adopted from Diego Perini
1329		assert( function( el ) {
1330
1331			var input;
1332
1333			// Select is set to empty string on purpose
1334			// This is to test IE's treatment of not explicitly
1335			// setting a boolean content attribute,
1336			// since its presence should be enough
1337			// https://bugs.jquery.com/ticket/12359
1338			docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
1339				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
1340				"<option selected=''></option></select>";
1341
1342			// Support: IE8, Opera 11-12.16
1343			// Nothing should be selected when empty strings follow ^= or $= or *=
1344			// The test attribute must be unknown in Opera but "safe" for WinRT
1345			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1346			if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) {
1347				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1348			}
1349
1350			// Support: IE8
1351			// Boolean attributes and "value" are not treated correctly
1352			if ( !el.querySelectorAll( "[selected]" ).length ) {
1353				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1354			}
1355
1356			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1357			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1358				rbuggyQSA.push( "~=" );
1359			}
1360
1361			// Support: IE 11+, Edge 15 - 18+
1362			// IE 11/Edge don't find elements on a `[name='']` query in some cases.
1363			// Adding a temporary attribute to the document before the selection works
1364			// around the issue.
1365			// Interestingly, IE 10 & older don't seem to have the issue.
1366			input = document.createElement( "input" );
1367			input.setAttribute( "name", "" );
1368			el.appendChild( input );
1369			if ( !el.querySelectorAll( "[name='']" ).length ) {
1370				rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
1371					whitespace + "*(?:''|\"\")" );
1372			}
1373
1374			// Webkit/Opera - :checked should return selected option elements
1375			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1376			// IE8 throws error here and will not see later tests
1377			if ( !el.querySelectorAll( ":checked" ).length ) {
1378				rbuggyQSA.push( ":checked" );
1379			}
1380
1381			// Support: Safari 8+, iOS 8+
1382			// https://bugs.webkit.org/show_bug.cgi?id=136851
1383			// In-page `selector#id sibling-combinator selector` fails
1384			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
1385				rbuggyQSA.push( ".#.+[+~]" );
1386			}
1387
1388			// Support: Firefox <=3.6 - 5 only
1389			// Old Firefox doesn't throw on a badly-escaped identifier.
1390			el.querySelectorAll( "\\\f" );
1391			rbuggyQSA.push( "[\\r\\n\\f]" );
1392		} );
1393
1394		assert( function( el ) {
1395			el.innerHTML = "<a href='' disabled='disabled'></a>" +
1396				"<select disabled='disabled'><option/></select>";
1397
1398			// Support: Windows 8 Native Apps
1399			// The type and name attributes are restricted during .innerHTML assignment
1400			var input = document.createElement( "input" );
1401			input.setAttribute( "type", "hidden" );
1402			el.appendChild( input ).setAttribute( "name", "D" );
1403
1404			// Support: IE8
1405			// Enforce case-sensitivity of name attribute
1406			if ( el.querySelectorAll( "[name=d]" ).length ) {
1407				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1408			}
1409
1410			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1411			// IE8 throws error here and will not see later tests
1412			if ( el.querySelectorAll( ":enabled" ).length !== 2 ) {
1413				rbuggyQSA.push( ":enabled", ":disabled" );
1414			}
1415
1416			// Support: IE9-11+
1417			// IE's :disabled selector does not pick up the children of disabled fieldsets
1418			docElem.appendChild( el ).disabled = true;
1419			if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
1420				rbuggyQSA.push( ":enabled", ":disabled" );
1421			}
1422
1423			// Support: Opera 10 - 11 only
1424			// Opera 10-11 does not throw on post-comma invalid pseudos
1425			el.querySelectorAll( "*,:x" );
1426			rbuggyQSA.push( ",.*:" );
1427		} );
1428	}
1429
1430	if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||
1431		docElem.webkitMatchesSelector ||
1432		docElem.mozMatchesSelector ||
1433		docElem.oMatchesSelector ||
1434		docElem.msMatchesSelector ) ) ) ) {
1435
1436		assert( function( el ) {
1437
1438			// Check to see if it's possible to do matchesSelector
1439			// on a disconnected node (IE 9)
1440			support.disconnectedMatch = matches.call( el, "*" );
1441
1442			// This should fail with an exception
1443			// Gecko does not error, returns false instead
1444			matches.call( el, "[s!='']:x" );
1445			rbuggyMatches.push( "!=", pseudos );
1446		} );
1447	}
1448
1449	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
1450	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) );
1451
1452	/* Contains
1453	---------------------------------------------------------------------- */
1454	hasCompare = rnative.test( docElem.compareDocumentPosition );
1455
1456	// Element contains another
1457	// Purposefully self-exclusive
1458	// As in, an element does not contain itself
1459	contains = hasCompare || rnative.test( docElem.contains ) ?
1460		function( a, b ) {
1461			var adown = a.nodeType === 9 ? a.documentElement : a,
1462				bup = b && b.parentNode;
1463			return a === bup || !!( bup && bup.nodeType === 1 && (
1464				adown.contains ?
1465					adown.contains( bup ) :
1466					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1467			) );
1468		} :
1469		function( a, b ) {
1470			if ( b ) {
1471				while ( ( b = b.parentNode ) ) {
1472					if ( b === a ) {
1473						return true;
1474					}
1475				}
1476			}
1477			return false;
1478		};
1479
1480	/* Sorting
1481	---------------------------------------------------------------------- */
1482
1483	// Document order sorting
1484	sortOrder = hasCompare ?
1485	function( a, b ) {
1486
1487		// Flag for duplicate removal
1488		if ( a === b ) {
1489			hasDuplicate = true;
1490			return 0;
1491		}
1492
1493		// Sort on method existence if only one input has compareDocumentPosition
1494		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1495		if ( compare ) {
1496			return compare;
1497		}
1498
1499		// Calculate position if both inputs belong to the same document
1500		// Support: IE 11+, Edge 17 - 18+
1501		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1502		// two documents; shallow comparisons work.
1503		// eslint-disable-next-line eqeqeq
1504		compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
1505			a.compareDocumentPosition( b ) :
1506
1507			// Otherwise we know they are disconnected
1508			1;
1509
1510		// Disconnected nodes
1511		if ( compare & 1 ||
1512			( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {
1513
1514			// Choose the first element that is related to our preferred document
1515			// Support: IE 11+, Edge 17 - 18+
1516			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1517			// two documents; shallow comparisons work.
1518			// eslint-disable-next-line eqeqeq
1519			if ( a == document || a.ownerDocument == preferredDoc &&
1520				contains( preferredDoc, a ) ) {
1521				return -1;
1522			}
1523
1524			// Support: IE 11+, Edge 17 - 18+
1525			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1526			// two documents; shallow comparisons work.
1527			// eslint-disable-next-line eqeqeq
1528			if ( b == document || b.ownerDocument == preferredDoc &&
1529				contains( preferredDoc, b ) ) {
1530				return 1;
1531			}
1532
1533			// Maintain original order
1534			return sortInput ?
1535				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1536				0;
1537		}
1538
1539		return compare & 4 ? -1 : 1;
1540	} :
1541	function( a, b ) {
1542
1543		// Exit early if the nodes are identical
1544		if ( a === b ) {
1545			hasDuplicate = true;
1546			return 0;
1547		}
1548
1549		var cur,
1550			i = 0,
1551			aup = a.parentNode,
1552			bup = b.parentNode,
1553			ap = [ a ],
1554			bp = [ b ];
1555
1556		// Parentless nodes are either documents or disconnected
1557		if ( !aup || !bup ) {
1558
1559			// Support: IE 11+, Edge 17 - 18+
1560			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1561			// two documents; shallow comparisons work.
1562			/* eslint-disable eqeqeq */
1563			return a == document ? -1 :
1564				b == document ? 1 :
1565				/* eslint-enable eqeqeq */
1566				aup ? -1 :
1567				bup ? 1 :
1568				sortInput ?
1569				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1570				0;
1571
1572		// If the nodes are siblings, we can do a quick check
1573		} else if ( aup === bup ) {
1574			return siblingCheck( a, b );
1575		}
1576
1577		// Otherwise we need full lists of their ancestors for comparison
1578		cur = a;
1579		while ( ( cur = cur.parentNode ) ) {
1580			ap.unshift( cur );
1581		}
1582		cur = b;
1583		while ( ( cur = cur.parentNode ) ) {
1584			bp.unshift( cur );
1585		}
1586
1587		// Walk down the tree looking for a discrepancy
1588		while ( ap[ i ] === bp[ i ] ) {
1589			i++;
1590		}
1591
1592		return i ?
1593
1594			// Do a sibling check if the nodes have a common ancestor
1595			siblingCheck( ap[ i ], bp[ i ] ) :
1596
1597			// Otherwise nodes in our document sort first
1598			// Support: IE 11+, Edge 17 - 18+
1599			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1600			// two documents; shallow comparisons work.
1601			/* eslint-disable eqeqeq */
1602			ap[ i ] == preferredDoc ? -1 :
1603			bp[ i ] == preferredDoc ? 1 :
1604			/* eslint-enable eqeqeq */
1605			0;
1606	};
1607
1608	return document;
1609};
1610
1611Sizzle.matches = function( expr, elements ) {
1612	return Sizzle( expr, null, null, elements );
1613};
1614
1615Sizzle.matchesSelector = function( elem, expr ) {
1616	setDocument( elem );
1617
1618	if ( support.matchesSelector && documentIsHTML &&
1619		!nonnativeSelectorCache[ expr + " " ] &&
1620		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1621		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1622
1623		try {
1624			var ret = matches.call( elem, expr );
1625
1626			// IE 9's matchesSelector returns false on disconnected nodes
1627			if ( ret || support.disconnectedMatch ||
1628
1629				// As well, disconnected nodes are said to be in a document
1630				// fragment in IE 9
1631				elem.document && elem.document.nodeType !== 11 ) {
1632				return ret;
1633			}
1634		} catch ( e ) {
1635			nonnativeSelectorCache( expr, true );
1636		}
1637	}
1638
1639	return Sizzle( expr, document, null, [ elem ] ).length > 0;
1640};
1641
1642Sizzle.contains = function( context, elem ) {
1643
1644	// Set document vars if needed
1645	// Support: IE 11+, Edge 17 - 18+
1646	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1647	// two documents; shallow comparisons work.
1648	// eslint-disable-next-line eqeqeq
1649	if ( ( context.ownerDocument || context ) != document ) {
1650		setDocument( context );
1651	}
1652	return contains( context, elem );
1653};
1654
1655Sizzle.attr = function( elem, name ) {
1656
1657	// Set document vars if needed
1658	// Support: IE 11+, Edge 17 - 18+
1659	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1660	// two documents; shallow comparisons work.
1661	// eslint-disable-next-line eqeqeq
1662	if ( ( elem.ownerDocument || elem ) != document ) {
1663		setDocument( elem );
1664	}
1665
1666	var fn = Expr.attrHandle[ name.toLowerCase() ],
1667
1668		// Don't get fooled by Object.prototype properties (jQuery #13807)
1669		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1670			fn( elem, name, !documentIsHTML ) :
1671			undefined;
1672
1673	return val !== undefined ?
1674		val :
1675		support.attributes || !documentIsHTML ?
1676			elem.getAttribute( name ) :
1677			( val = elem.getAttributeNode( name ) ) && val.specified ?
1678				val.value :
1679				null;
1680};
1681
1682Sizzle.escape = function( sel ) {
1683	return ( sel + "" ).replace( rcssescape, fcssescape );
1684};
1685
1686Sizzle.error = function( msg ) {
1687	throw new Error( "Syntax error, unrecognized expression: " + msg );
1688};
1689
1690/**
1691 * Document sorting and removing duplicates
1692 * @param {ArrayLike} results
1693 */
1694Sizzle.uniqueSort = function( results ) {
1695	var elem,
1696		duplicates = [],
1697		j = 0,
1698		i = 0;
1699
1700	// Unless we *know* we can detect duplicates, assume their presence
1701	hasDuplicate = !support.detectDuplicates;
1702	sortInput = !support.sortStable && results.slice( 0 );
1703	results.sort( sortOrder );
1704
1705	if ( hasDuplicate ) {
1706		while ( ( elem = results[ i++ ] ) ) {
1707			if ( elem === results[ i ] ) {
1708				j = duplicates.push( i );
1709			}
1710		}
1711		while ( j-- ) {
1712			results.splice( duplicates[ j ], 1 );
1713		}
1714	}
1715
1716	// Clear input after sorting to release objects
1717	// See https://github.com/jquery/sizzle/pull/225
1718	sortInput = null;
1719
1720	return results;
1721};
1722
1723/**
1724 * Utility function for retrieving the text value of an array of DOM nodes
1725 * @param {Array|Element} elem
1726 */
1727getText = Sizzle.getText = function( elem ) {
1728	var node,
1729		ret = "",
1730		i = 0,
1731		nodeType = elem.nodeType;
1732
1733	if ( !nodeType ) {
1734
1735		// If no nodeType, this is expected to be an array
1736		while ( ( node = elem[ i++ ] ) ) {
1737
1738			// Do not traverse comment nodes
1739			ret += getText( node );
1740		}
1741	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1742
1743		// Use textContent for elements
1744		// innerText usage removed for consistency of new lines (jQuery #11153)
1745		if ( typeof elem.textContent === "string" ) {
1746			return elem.textContent;
1747		} else {
1748
1749			// Traverse its children
1750			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1751				ret += getText( elem );
1752			}
1753		}
1754	} else if ( nodeType === 3 || nodeType === 4 ) {
1755		return elem.nodeValue;
1756	}
1757
1758	// Do not include comment or processing instruction nodes
1759
1760	return ret;
1761};
1762
1763Expr = Sizzle.selectors = {
1764
1765	// Can be adjusted by the user
1766	cacheLength: 50,
1767
1768	createPseudo: markFunction,
1769
1770	match: matchExpr,
1771
1772	attrHandle: {},
1773
1774	find: {},
1775
1776	relative: {
1777		">": { dir: "parentNode", first: true },
1778		" ": { dir: "parentNode" },
1779		"+": { dir: "previousSibling", first: true },
1780		"~": { dir: "previousSibling" }
1781	},
1782
1783	preFilter: {
1784		"ATTR": function( match ) {
1785			match[ 1 ] = match[ 1 ].replace( runescape, funescape );
1786
1787			// Move the given value to match[3] whether quoted or unquoted
1788			match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||
1789				match[ 5 ] || "" ).replace( runescape, funescape );
1790
1791			if ( match[ 2 ] === "~=" ) {
1792				match[ 3 ] = " " + match[ 3 ] + " ";
1793			}
1794
1795			return match.slice( 0, 4 );
1796		},
1797
1798		"CHILD": function( match ) {
1799
1800			/* matches from matchExpr["CHILD"]
1801				1 type (only|nth|...)
1802				2 what (child|of-type)
1803				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1804				4 xn-component of xn+y argument ([+-]?\d*n|)
1805				5 sign of xn-component
1806				6 x of xn-component
1807				7 sign of y-component
1808				8 y of y-component
1809			*/
1810			match[ 1 ] = match[ 1 ].toLowerCase();
1811
1812			if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
1813
1814				// nth-* requires argument
1815				if ( !match[ 3 ] ) {
1816					Sizzle.error( match[ 0 ] );
1817				}
1818
1819				// numeric x and y parameters for Expr.filter.CHILD
1820				// remember that false/true cast respectively to 0/1
1821				match[ 4 ] = +( match[ 4 ] ?
1822					match[ 5 ] + ( match[ 6 ] || 1 ) :
1823					2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) );
1824				match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
1825
1826				// other types prohibit arguments
1827			} else if ( match[ 3 ] ) {
1828				Sizzle.error( match[ 0 ] );
1829			}
1830
1831			return match;
1832		},
1833
1834		"PSEUDO": function( match ) {
1835			var excess,
1836				unquoted = !match[ 6 ] && match[ 2 ];
1837
1838			if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) {
1839				return null;
1840			}
1841
1842			// Accept quoted arguments as-is
1843			if ( match[ 3 ] ) {
1844				match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
1845
1846			// Strip excess characters from unquoted arguments
1847			} else if ( unquoted && rpseudo.test( unquoted ) &&
1848
1849				// Get excess from tokenize (recursively)
1850				( excess = tokenize( unquoted, true ) ) &&
1851
1852				// advance to the next closing parenthesis
1853				( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
1854
1855				// excess is a negative index
1856				match[ 0 ] = match[ 0 ].slice( 0, excess );
1857				match[ 2 ] = unquoted.slice( 0, excess );
1858			}
1859
1860			// Return only captures needed by the pseudo filter method (type and argument)
1861			return match.slice( 0, 3 );
1862		}
1863	},
1864
1865	filter: {
1866
1867		"TAG": function( nodeNameSelector ) {
1868			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1869			return nodeNameSelector === "*" ?
1870				function() {
1871					return true;
1872				} :
1873				function( elem ) {
1874					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1875				};
1876		},
1877
1878		"CLASS": function( className ) {
1879			var pattern = classCache[ className + " " ];
1880
1881			return pattern ||
1882				( pattern = new RegExp( "(^|" + whitespace +
1883					")" + className + "(" + whitespace + "|$)" ) ) && classCache(
1884						className, function( elem ) {
1885							return pattern.test(
1886								typeof elem.className === "string" && elem.className ||
1887								typeof elem.getAttribute !== "undefined" &&
1888									elem.getAttribute( "class" ) ||
1889								""
1890							);
1891				} );
1892		},
1893
1894		"ATTR": function( name, operator, check ) {
1895			return function( elem ) {
1896				var result = Sizzle.attr( elem, name );
1897
1898				if ( result == null ) {
1899					return operator === "!=";
1900				}
1901				if ( !operator ) {
1902					return true;
1903				}
1904
1905				result += "";
1906
1907				/* eslint-disable max-len */
1908
1909				return operator === "=" ? result === check :
1910					operator === "!=" ? result !== check :
1911					operator === "^=" ? check && result.indexOf( check ) === 0 :
1912					operator === "*=" ? check && result.indexOf( check ) > -1 :
1913					operator === "$=" ? check && result.slice( -check.length ) === check :
1914					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1915					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1916					false;
1917				/* eslint-enable max-len */
1918
1919			};
1920		},
1921
1922		"CHILD": function( type, what, _argument, first, last ) {
1923			var simple = type.slice( 0, 3 ) !== "nth",
1924				forward = type.slice( -4 ) !== "last",
1925				ofType = what === "of-type";
1926
1927			return first === 1 && last === 0 ?
1928
1929				// Shortcut for :nth-*(n)
1930				function( elem ) {
1931					return !!elem.parentNode;
1932				} :
1933
1934				function( elem, _context, xml ) {
1935					var cache, uniqueCache, outerCache, node, nodeIndex, start,
1936						dir = simple !== forward ? "nextSibling" : "previousSibling",
1937						parent = elem.parentNode,
1938						name = ofType && elem.nodeName.toLowerCase(),
1939						useCache = !xml && !ofType,
1940						diff = false;
1941
1942					if ( parent ) {
1943
1944						// :(first|last|only)-(child|of-type)
1945						if ( simple ) {
1946							while ( dir ) {
1947								node = elem;
1948								while ( ( node = node[ dir ] ) ) {
1949									if ( ofType ?
1950										node.nodeName.toLowerCase() === name :
1951										node.nodeType === 1 ) {
1952
1953										return false;
1954									}
1955								}
1956
1957								// Reverse direction for :only-* (if we haven't yet done so)
1958								start = dir = type === "only" && !start && "nextSibling";
1959							}
1960							return true;
1961						}
1962
1963						start = [ forward ? parent.firstChild : parent.lastChild ];
1964
1965						// non-xml :nth-child(...) stores cache data on `parent`
1966						if ( forward && useCache ) {
1967
1968							// Seek `elem` from a previously-cached index
1969
1970							// ...in a gzip-friendly way
1971							node = parent;
1972							outerCache = node[ expando ] || ( node[ expando ] = {} );
1973
1974							// Support: IE <9 only
1975							// Defend against cloned attroperties (jQuery gh-1709)
1976							uniqueCache = outerCache[ node.uniqueID ] ||
1977								( outerCache[ node.uniqueID ] = {} );
1978
1979							cache = uniqueCache[ type ] || [];
1980							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1981							diff = nodeIndex && cache[ 2 ];
1982							node = nodeIndex && parent.childNodes[ nodeIndex ];
1983
1984							while ( ( node = ++nodeIndex && node && node[ dir ] ||
1985
1986								// Fallback to seeking `elem` from the start
1987								( diff = nodeIndex = 0 ) || start.pop() ) ) {
1988
1989								// When found, cache indexes on `parent` and break
1990								if ( node.nodeType === 1 && ++diff && node === elem ) {
1991									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1992									break;
1993								}
1994							}
1995
1996						} else {
1997
1998							// Use previously-cached element index if available
1999							if ( useCache ) {
2000
2001								// ...in a gzip-friendly way
2002								node = elem;
2003								outerCache = node[ expando ] || ( node[ expando ] = {} );
2004
2005								// Support: IE <9 only
2006								// Defend against cloned attroperties (jQuery gh-1709)
2007								uniqueCache = outerCache[ node.uniqueID ] ||
2008									( outerCache[ node.uniqueID ] = {} );
2009
2010								cache = uniqueCache[ type ] || [];
2011								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
2012								diff = nodeIndex;
2013							}
2014
2015							// xml :nth-child(...)
2016							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
2017							if ( diff === false ) {
2018
2019								// Use the same loop as above to seek `elem` from the start
2020								while ( ( node = ++nodeIndex && node && node[ dir ] ||
2021									( diff = nodeIndex = 0 ) || start.pop() ) ) {
2022
2023									if ( ( ofType ?
2024										node.nodeName.toLowerCase() === name :
2025										node.nodeType === 1 ) &&
2026										++diff ) {
2027
2028										// Cache the index of each encountered element
2029										if ( useCache ) {
2030											outerCache = node[ expando ] ||
2031												( node[ expando ] = {} );
2032
2033											// Support: IE <9 only
2034											// Defend against cloned attroperties (jQuery gh-1709)
2035											uniqueCache = outerCache[ node.uniqueID ] ||
2036												( outerCache[ node.uniqueID ] = {} );
2037
2038											uniqueCache[ type ] = [ dirruns, diff ];
2039										}
2040
2041										if ( node === elem ) {
2042											break;
2043										}
2044									}
2045								}
2046							}
2047						}
2048
2049						// Incorporate the offset, then check against cycle size
2050						diff -= last;
2051						return diff === first || ( diff % first === 0 && diff / first >= 0 );
2052					}
2053				};
2054		},
2055
2056		"PSEUDO": function( pseudo, argument ) {
2057
2058			// pseudo-class names are case-insensitive
2059			// http://www.w3.org/TR/selectors/#pseudo-classes
2060			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2061			// Remember that setFilters inherits from pseudos
2062			var args,
2063				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2064					Sizzle.error( "unsupported pseudo: " + pseudo );
2065
2066			// The user may use createPseudo to indicate that
2067			// arguments are needed to create the filter function
2068			// just as Sizzle does
2069			if ( fn[ expando ] ) {
2070				return fn( argument );
2071			}
2072
2073			// But maintain support for old signatures
2074			if ( fn.length > 1 ) {
2075				args = [ pseudo, pseudo, "", argument ];
2076				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2077					markFunction( function( seed, matches ) {
2078						var idx,
2079							matched = fn( seed, argument ),
2080							i = matched.length;
2081						while ( i-- ) {
2082							idx = indexOf( seed, matched[ i ] );
2083							seed[ idx ] = !( matches[ idx ] = matched[ i ] );
2084						}
2085					} ) :
2086					function( elem ) {
2087						return fn( elem, 0, args );
2088					};
2089			}
2090
2091			return fn;
2092		}
2093	},
2094
2095	pseudos: {
2096
2097		// Potentially complex pseudos
2098		"not": markFunction( function( selector ) {
2099
2100			// Trim the selector passed to compile
2101			// to avoid treating leading and trailing
2102			// spaces as combinators
2103			var input = [],
2104				results = [],
2105				matcher = compile( selector.replace( rtrim, "$1" ) );
2106
2107			return matcher[ expando ] ?
2108				markFunction( function( seed, matches, _context, xml ) {
2109					var elem,
2110						unmatched = matcher( seed, null, xml, [] ),
2111						i = seed.length;
2112
2113					// Match elements unmatched by `matcher`
2114					while ( i-- ) {
2115						if ( ( elem = unmatched[ i ] ) ) {
2116							seed[ i ] = !( matches[ i ] = elem );
2117						}
2118					}
2119				} ) :
2120				function( elem, _context, xml ) {
2121					input[ 0 ] = elem;
2122					matcher( input, null, xml, results );
2123
2124					// Don't keep the element (issue #299)
2125					input[ 0 ] = null;
2126					return !results.pop();
2127				};
2128		} ),
2129
2130		"has": markFunction( function( selector ) {
2131			return function( elem ) {
2132				return Sizzle( selector, elem ).length > 0;
2133			};
2134		} ),
2135
2136		"contains": markFunction( function( text ) {
2137			text = text.replace( runescape, funescape );
2138			return function( elem ) {
2139				return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
2140			};
2141		} ),
2142
2143		// "Whether an element is represented by a :lang() selector
2144		// is based solely on the element's language value
2145		// being equal to the identifier C,
2146		// or beginning with the identifier C immediately followed by "-".
2147		// The matching of C against the element's language value is performed case-insensitively.
2148		// The identifier C does not have to be a valid language name."
2149		// http://www.w3.org/TR/selectors/#lang-pseudo
2150		"lang": markFunction( function( lang ) {
2151
2152			// lang value must be a valid identifier
2153			if ( !ridentifier.test( lang || "" ) ) {
2154				Sizzle.error( "unsupported lang: " + lang );
2155			}
2156			lang = lang.replace( runescape, funescape ).toLowerCase();
2157			return function( elem ) {
2158				var elemLang;
2159				do {
2160					if ( ( elemLang = documentIsHTML ?
2161						elem.lang :
2162						elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
2163
2164						elemLang = elemLang.toLowerCase();
2165						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2166					}
2167				} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
2168				return false;
2169			};
2170		} ),
2171
2172		// Miscellaneous
2173		"target": function( elem ) {
2174			var hash = window.location && window.location.hash;
2175			return hash && hash.slice( 1 ) === elem.id;
2176		},
2177
2178		"root": function( elem ) {
2179			return elem === docElem;
2180		},
2181
2182		"focus": function( elem ) {
2183			return elem === document.activeElement &&
2184				( !document.hasFocus || document.hasFocus() ) &&
2185				!!( elem.type || elem.href || ~elem.tabIndex );
2186		},
2187
2188		// Boolean properties
2189		"enabled": createDisabledPseudo( false ),
2190		"disabled": createDisabledPseudo( true ),
2191
2192		"checked": function( elem ) {
2193
2194			// In CSS3, :checked should return both checked and selected elements
2195			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2196			var nodeName = elem.nodeName.toLowerCase();
2197			return ( nodeName === "input" && !!elem.checked ) ||
2198				( nodeName === "option" && !!elem.selected );
2199		},
2200
2201		"selected": function( elem ) {
2202
2203			// Accessing this property makes selected-by-default
2204			// options in Safari work properly
2205			if ( elem.parentNode ) {
2206				// eslint-disable-next-line no-unused-expressions
2207				elem.parentNode.selectedIndex;
2208			}
2209
2210			return elem.selected === true;
2211		},
2212
2213		// Contents
2214		"empty": function( elem ) {
2215
2216			// http://www.w3.org/TR/selectors/#empty-pseudo
2217			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2218			//   but not by others (comment: 8; processing instruction: 7; etc.)
2219			// nodeType < 6 works because attributes (2) do not appear as children
2220			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2221				if ( elem.nodeType < 6 ) {
2222					return false;
2223				}
2224			}
2225			return true;
2226		},
2227
2228		"parent": function( elem ) {
2229			return !Expr.pseudos[ "empty" ]( elem );
2230		},
2231
2232		// Element/input types
2233		"header": function( elem ) {
2234			return rheader.test( elem.nodeName );
2235		},
2236
2237		"input": function( elem ) {
2238			return rinputs.test( elem.nodeName );
2239		},
2240
2241		"button": function( elem ) {
2242			var name = elem.nodeName.toLowerCase();
2243			return name === "input" && elem.type === "button" || name === "button";
2244		},
2245
2246		"text": function( elem ) {
2247			var attr;
2248			return elem.nodeName.toLowerCase() === "input" &&
2249				elem.type === "text" &&
2250
2251				// Support: IE<8
2252				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2253				( ( attr = elem.getAttribute( "type" ) ) == null ||
2254					attr.toLowerCase() === "text" );
2255		},
2256
2257		// Position-in-collection
2258		"first": createPositionalPseudo( function() {
2259			return [ 0 ];
2260		} ),
2261
2262		"last": createPositionalPseudo( function( _matchIndexes, length ) {
2263			return [ length - 1 ];
2264		} ),
2265
2266		"eq": createPositionalPseudo( function( _matchIndexes, length, argument ) {
2267			return [ argument < 0 ? argument + length : argument ];
2268		} ),
2269
2270		"even": createPositionalPseudo( function( matchIndexes, length ) {
2271			var i = 0;
2272			for ( ; i < length; i += 2 ) {
2273				matchIndexes.push( i );
2274			}
2275			return matchIndexes;
2276		} ),
2277
2278		"odd": createPositionalPseudo( function( matchIndexes, length ) {
2279			var i = 1;
2280			for ( ; i < length; i += 2 ) {
2281				matchIndexes.push( i );
2282			}
2283			return matchIndexes;
2284		} ),
2285
2286		"lt": createPositionalPseudo( function( matchIndexes, length, argument ) {
2287			var i = argument < 0 ?
2288				argument + length :
2289				argument > length ?
2290					length :
2291					argument;
2292			for ( ; --i >= 0; ) {
2293				matchIndexes.push( i );
2294			}
2295			return matchIndexes;
2296		} ),
2297
2298		"gt": createPositionalPseudo( function( matchIndexes, length, argument ) {
2299			var i = argument < 0 ? argument + length : argument;
2300			for ( ; ++i < length; ) {
2301				matchIndexes.push( i );
2302			}
2303			return matchIndexes;
2304		} )
2305	}
2306};
2307
2308Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ];
2309
2310// Add button/input type pseudos
2311for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2312	Expr.pseudos[ i ] = createInputPseudo( i );
2313}
2314for ( i in { submit: true, reset: true } ) {
2315	Expr.pseudos[ i ] = createButtonPseudo( i );
2316}
2317
2318// Easy API for creating new setFilters
2319function setFilters() {}
2320setFilters.prototype = Expr.filters = Expr.pseudos;
2321Expr.setFilters = new setFilters();
2322
2323tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2324	var matched, match, tokens, type,
2325		soFar, groups, preFilters,
2326		cached = tokenCache[ selector + " " ];
2327
2328	if ( cached ) {
2329		return parseOnly ? 0 : cached.slice( 0 );
2330	}
2331
2332	soFar = selector;
2333	groups = [];
2334	preFilters = Expr.preFilter;
2335
2336	while ( soFar ) {
2337
2338		// Comma and first run
2339		if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
2340			if ( match ) {
2341
2342				// Don't consume trailing commas as valid
2343				soFar = soFar.slice( match[ 0 ].length ) || soFar;
2344			}
2345			groups.push( ( tokens = [] ) );
2346		}
2347
2348		matched = false;
2349
2350		// Combinators
2351		if ( ( match = rcombinators.exec( soFar ) ) ) {
2352			matched = match.shift();
2353			tokens.push( {
2354				value: matched,
2355
2356				// Cast descendant combinators to space
2357				type: match[ 0 ].replace( rtrim, " " )
2358			} );
2359			soFar = soFar.slice( matched.length );
2360		}
2361
2362		// Filters
2363		for ( type in Expr.filter ) {
2364			if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
2365				( match = preFilters[ type ]( match ) ) ) ) {
2366				matched = match.shift();
2367				tokens.push( {
2368					value: matched,
2369					type: type,
2370					matches: match
2371				} );
2372				soFar = soFar.slice( matched.length );
2373			}
2374		}
2375
2376		if ( !matched ) {
2377			break;
2378		}
2379	}
2380
2381	// Return the length of the invalid excess
2382	// if we're just parsing
2383	// Otherwise, throw an error or return tokens
2384	return parseOnly ?
2385		soFar.length :
2386		soFar ?
2387			Sizzle.error( selector ) :
2388
2389			// Cache the tokens
2390			tokenCache( selector, groups ).slice( 0 );
2391};
2392
2393function toSelector( tokens ) {
2394	var i = 0,
2395		len = tokens.length,
2396		selector = "";
2397	for ( ; i < len; i++ ) {
2398		selector += tokens[ i ].value;
2399	}
2400	return selector;
2401}
2402
2403function addCombinator( matcher, combinator, base ) {
2404	var dir = combinator.dir,
2405		skip = combinator.next,
2406		key = skip || dir,
2407		checkNonElements = base && key === "parentNode",
2408		doneName = done++;
2409
2410	return combinator.first ?
2411
2412		// Check against closest ancestor/preceding element
2413		function( elem, context, xml ) {
2414			while ( ( elem = elem[ dir ] ) ) {
2415				if ( elem.nodeType === 1 || checkNonElements ) {
2416					return matcher( elem, context, xml );
2417				}
2418			}
2419			return false;
2420		} :
2421
2422		// Check against all ancestor/preceding elements
2423		function( elem, context, xml ) {
2424			var oldCache, uniqueCache, outerCache,
2425				newCache = [ dirruns, doneName ];
2426
2427			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2428			if ( xml ) {
2429				while ( ( elem = elem[ dir ] ) ) {
2430					if ( elem.nodeType === 1 || checkNonElements ) {
2431						if ( matcher( elem, context, xml ) ) {
2432							return true;
2433						}
2434					}
2435				}
2436			} else {
2437				while ( ( elem = elem[ dir ] ) ) {
2438					if ( elem.nodeType === 1 || checkNonElements ) {
2439						outerCache = elem[ expando ] || ( elem[ expando ] = {} );
2440
2441						// Support: IE <9 only
2442						// Defend against cloned attroperties (jQuery gh-1709)
2443						uniqueCache = outerCache[ elem.uniqueID ] ||
2444							( outerCache[ elem.uniqueID ] = {} );
2445
2446						if ( skip && skip === elem.nodeName.toLowerCase() ) {
2447							elem = elem[ dir ] || elem;
2448						} else if ( ( oldCache = uniqueCache[ key ] ) &&
2449							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2450
2451							// Assign to newCache so results back-propagate to previous elements
2452							return ( newCache[ 2 ] = oldCache[ 2 ] );
2453						} else {
2454
2455							// Reuse newcache so results back-propagate to previous elements
2456							uniqueCache[ key ] = newCache;
2457
2458							// A match means we're done; a fail means we have to keep checking
2459							if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
2460								return true;
2461							}
2462						}
2463					}
2464				}
2465			}
2466			return false;
2467		};
2468}
2469
2470function elementMatcher( matchers ) {
2471	return matchers.length > 1 ?
2472		function( elem, context, xml ) {
2473			var i = matchers.length;
2474			while ( i-- ) {
2475				if ( !matchers[ i ]( elem, context, xml ) ) {
2476					return false;
2477				}
2478			}
2479			return true;
2480		} :
2481		matchers[ 0 ];
2482}
2483
2484function multipleContexts( selector, contexts, results ) {
2485	var i = 0,
2486		len = contexts.length;
2487	for ( ; i < len; i++ ) {
2488		Sizzle( selector, contexts[ i ], results );
2489	}
2490	return results;
2491}
2492
2493function condense( unmatched, map, filter, context, xml ) {
2494	var elem,
2495		newUnmatched = [],
2496		i = 0,
2497		len = unmatched.length,
2498		mapped = map != null;
2499
2500	for ( ; i < len; i++ ) {
2501		if ( ( elem = unmatched[ i ] ) ) {
2502			if ( !filter || filter( elem, context, xml ) ) {
2503				newUnmatched.push( elem );
2504				if ( mapped ) {
2505					map.push( i );
2506				}
2507			}
2508		}
2509	}
2510
2511	return newUnmatched;
2512}
2513
2514function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2515	if ( postFilter && !postFilter[ expando ] ) {
2516		postFilter = setMatcher( postFilter );
2517	}
2518	if ( postFinder && !postFinder[ expando ] ) {
2519		postFinder = setMatcher( postFinder, postSelector );
2520	}
2521	return markFunction( function( seed, results, context, xml ) {
2522		var temp, i, elem,
2523			preMap = [],
2524			postMap = [],
2525			preexisting = results.length,
2526
2527			// Get initial elements from seed or context
2528			elems = seed || multipleContexts(
2529				selector || "*",
2530				context.nodeType ? [ context ] : context,
2531				[]
2532			),
2533
2534			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2535			matcherIn = preFilter && ( seed || !selector ) ?
2536				condense( elems, preMap, preFilter, context, xml ) :
2537				elems,
2538
2539			matcherOut = matcher ?
2540
2541				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2542				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2543
2544					// ...intermediate processing is necessary
2545					[] :
2546
2547					// ...otherwise use results directly
2548					results :
2549				matcherIn;
2550
2551		// Find primary matches
2552		if ( matcher ) {
2553			matcher( matcherIn, matcherOut, context, xml );
2554		}
2555
2556		// Apply postFilter
2557		if ( postFilter ) {
2558			temp = condense( matcherOut, postMap );
2559			postFilter( temp, [], context, xml );
2560
2561			// Un-match failing elements by moving them back to matcherIn
2562			i = temp.length;
2563			while ( i-- ) {
2564				if ( ( elem = temp[ i ] ) ) {
2565					matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
2566				}
2567			}
2568		}
2569
2570		if ( seed ) {
2571			if ( postFinder || preFilter ) {
2572				if ( postFinder ) {
2573
2574					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2575					temp = [];
2576					i = matcherOut.length;
2577					while ( i-- ) {
2578						if ( ( elem = matcherOut[ i ] ) ) {
2579
2580							// Restore matcherIn since elem is not yet a final match
2581							temp.push( ( matcherIn[ i ] = elem ) );
2582						}
2583					}
2584					postFinder( null, ( matcherOut = [] ), temp, xml );
2585				}
2586
2587				// Move matched elements from seed to results to keep them synchronized
2588				i = matcherOut.length;
2589				while ( i-- ) {
2590					if ( ( elem = matcherOut[ i ] ) &&
2591						( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {
2592
2593						seed[ temp ] = !( results[ temp ] = elem );
2594					}
2595				}
2596			}
2597
2598		// Add elements to results, through postFinder if defined
2599		} else {
2600			matcherOut = condense(
2601				matcherOut === results ?
2602					matcherOut.splice( preexisting, matcherOut.length ) :
2603					matcherOut
2604			);
2605			if ( postFinder ) {
2606				postFinder( null, results, matcherOut, xml );
2607			} else {
2608				push.apply( results, matcherOut );
2609			}
2610		}
2611	} );
2612}
2613
2614function matcherFromTokens( tokens ) {
2615	var checkContext, matcher, j,
2616		len = tokens.length,
2617		leadingRelative = Expr.relative[ tokens[ 0 ].type ],
2618		implicitRelative = leadingRelative || Expr.relative[ " " ],
2619		i = leadingRelative ? 1 : 0,
2620
2621		// The foundational matcher ensures that elements are reachable from top-level context(s)
2622		matchContext = addCombinator( function( elem ) {
2623			return elem === checkContext;
2624		}, implicitRelative, true ),
2625		matchAnyContext = addCombinator( function( elem ) {
2626			return indexOf( checkContext, elem ) > -1;
2627		}, implicitRelative, true ),
2628		matchers = [ function( elem, context, xml ) {
2629			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2630				( checkContext = context ).nodeType ?
2631					matchContext( elem, context, xml ) :
2632					matchAnyContext( elem, context, xml ) );
2633
2634			// Avoid hanging onto element (issue #299)
2635			checkContext = null;
2636			return ret;
2637		} ];
2638
2639	for ( ; i < len; i++ ) {
2640		if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
2641			matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
2642		} else {
2643			matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
2644
2645			// Return special upon seeing a positional matcher
2646			if ( matcher[ expando ] ) {
2647
2648				// Find the next relative operator (if any) for proper handling
2649				j = ++i;
2650				for ( ; j < len; j++ ) {
2651					if ( Expr.relative[ tokens[ j ].type ] ) {
2652						break;
2653					}
2654				}
2655				return setMatcher(
2656					i > 1 && elementMatcher( matchers ),
2657					i > 1 && toSelector(
2658
2659					// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2660					tokens
2661						.slice( 0, i - 1 )
2662						.concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
2663					).replace( rtrim, "$1" ),
2664					matcher,
2665					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2666					j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
2667					j < len && toSelector( tokens )
2668				);
2669			}
2670			matchers.push( matcher );
2671		}
2672	}
2673
2674	return elementMatcher( matchers );
2675}
2676
2677function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2678	var bySet = setMatchers.length > 0,
2679		byElement = elementMatchers.length > 0,
2680		superMatcher = function( seed, context, xml, results, outermost ) {
2681			var elem, j, matcher,
2682				matchedCount = 0,
2683				i = "0",
2684				unmatched = seed && [],
2685				setMatched = [],
2686				contextBackup = outermostContext,
2687
2688				// We must always have either seed elements or outermost context
2689				elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ),
2690
2691				// Use integer dirruns iff this is the outermost matcher
2692				dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
2693				len = elems.length;
2694
2695			if ( outermost ) {
2696
2697				// Support: IE 11+, Edge 17 - 18+
2698				// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2699				// two documents; shallow comparisons work.
2700				// eslint-disable-next-line eqeqeq
2701				outermostContext = context == document || context || outermost;
2702			}
2703
2704			// Add elements passing elementMatchers directly to results
2705			// Support: IE<9, Safari
2706			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2707			for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
2708				if ( byElement && elem ) {
2709					j = 0;
2710
2711					// Support: IE 11+, Edge 17 - 18+
2712					// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2713					// two documents; shallow comparisons work.
2714					// eslint-disable-next-line eqeqeq
2715					if ( !context && elem.ownerDocument != document ) {
2716						setDocument( elem );
2717						xml = !documentIsHTML;
2718					}
2719					while ( ( matcher = elementMatchers[ j++ ] ) ) {
2720						if ( matcher( elem, context || document, xml ) ) {
2721							results.push( elem );
2722							break;
2723						}
2724					}
2725					if ( outermost ) {
2726						dirruns = dirrunsUnique;
2727					}
2728				}
2729
2730				// Track unmatched elements for set filters
2731				if ( bySet ) {
2732
2733					// They will have gone through all possible matchers
2734					if ( ( elem = !matcher && elem ) ) {
2735						matchedCount--;
2736					}
2737
2738					// Lengthen the array for every element, matched or not
2739					if ( seed ) {
2740						unmatched.push( elem );
2741					}
2742				}
2743			}
2744
2745			// `i` is now the count of elements visited above, and adding it to `matchedCount`
2746			// makes the latter nonnegative.
2747			matchedCount += i;
2748
2749			// Apply set filters to unmatched elements
2750			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2751			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2752			// no element matchers and no seed.
2753			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2754			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2755			// numerically zero.
2756			if ( bySet && i !== matchedCount ) {
2757				j = 0;
2758				while ( ( matcher = setMatchers[ j++ ] ) ) {
2759					matcher( unmatched, setMatched, context, xml );
2760				}
2761
2762				if ( seed ) {
2763
2764					// Reintegrate element matches to eliminate the need for sorting
2765					if ( matchedCount > 0 ) {
2766						while ( i-- ) {
2767							if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
2768								setMatched[ i ] = pop.call( results );
2769							}
2770						}
2771					}
2772
2773					// Discard index placeholder values to get only actual matches
2774					setMatched = condense( setMatched );
2775				}
2776
2777				// Add matches to results
2778				push.apply( results, setMatched );
2779
2780				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2781				if ( outermost && !seed && setMatched.length > 0 &&
2782					( matchedCount + setMatchers.length ) > 1 ) {
2783
2784					Sizzle.uniqueSort( results );
2785				}
2786			}
2787
2788			// Override manipulation of globals by nested matchers
2789			if ( outermost ) {
2790				dirruns = dirrunsUnique;
2791				outermostContext = contextBackup;
2792			}
2793
2794			return unmatched;
2795		};
2796
2797	return bySet ?
2798		markFunction( superMatcher ) :
2799		superMatcher;
2800}
2801
2802compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2803	var i,
2804		setMatchers = [],
2805		elementMatchers = [],
2806		cached = compilerCache[ selector + " " ];
2807
2808	if ( !cached ) {
2809
2810		// Generate a function of recursive functions that can be used to check each element
2811		if ( !match ) {
2812			match = tokenize( selector );
2813		}
2814		i = match.length;
2815		while ( i-- ) {
2816			cached = matcherFromTokens( match[ i ] );
2817			if ( cached[ expando ] ) {
2818				setMatchers.push( cached );
2819			} else {
2820				elementMatchers.push( cached );
2821			}
2822		}
2823
2824		// Cache the compiled function
2825		cached = compilerCache(
2826			selector,
2827			matcherFromGroupMatchers( elementMatchers, setMatchers )
2828		);
2829
2830		// Save selector and tokenization
2831		cached.selector = selector;
2832	}
2833	return cached;
2834};
2835
2836/**
2837 * A low-level selection function that works with Sizzle's compiled
2838 *  selector functions
2839 * @param {String|Function} selector A selector or a pre-compiled
2840 *  selector function built with Sizzle.compile
2841 * @param {Element} context
2842 * @param {Array} [results]
2843 * @param {Array} [seed] A set of elements to match against
2844 */
2845select = Sizzle.select = function( selector, context, results, seed ) {
2846	var i, tokens, token, type, find,
2847		compiled = typeof selector === "function" && selector,
2848		match = !seed && tokenize( ( selector = compiled.selector || selector ) );
2849
2850	results = results || [];
2851
2852	// Try to minimize operations if there is only one selector in the list and no seed
2853	// (the latter of which guarantees us context)
2854	if ( match.length === 1 ) {
2855
2856		// Reduce context if the leading compound selector is an ID
2857		tokens = match[ 0 ] = match[ 0 ].slice( 0 );
2858		if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
2859			context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
2860
2861			context = ( Expr.find[ "ID" ]( token.matches[ 0 ]
2862				.replace( runescape, funescape ), context ) || [] )[ 0 ];
2863			if ( !context ) {
2864				return results;
2865
2866			// Precompiled matchers will still verify ancestry, so step up a level
2867			} else if ( compiled ) {
2868				context = context.parentNode;
2869			}
2870
2871			selector = selector.slice( tokens.shift().value.length );
2872		}
2873
2874		// Fetch a seed set for right-to-left matching
2875		i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length;
2876		while ( i-- ) {
2877			token = tokens[ i ];
2878
2879			// Abort if we hit a combinator
2880			if ( Expr.relative[ ( type = token.type ) ] ) {
2881				break;
2882			}
2883			if ( ( find = Expr.find[ type ] ) ) {
2884
2885				// Search, expanding context for leading sibling combinators
2886				if ( ( seed = find(
2887					token.matches[ 0 ].replace( runescape, funescape ),
2888					rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||
2889						context
2890				) ) ) {
2891
2892					// If seed is empty or no tokens remain, we can return early
2893					tokens.splice( i, 1 );
2894					selector = seed.length && toSelector( tokens );
2895					if ( !selector ) {
2896						push.apply( results, seed );
2897						return results;
2898					}
2899
2900					break;
2901				}
2902			}
2903		}
2904	}
2905
2906	// Compile and execute a filtering function if one is not provided
2907	// Provide `match` to avoid retokenization if we modified the selector above
2908	( compiled || compile( selector, match ) )(
2909		seed,
2910		context,
2911		!documentIsHTML,
2912		results,
2913		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2914	);
2915	return results;
2916};
2917
2918// One-time assignments
2919
2920// Sort stability
2921support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
2922
2923// Support: Chrome 14-35+
2924// Always assume duplicates if they aren't passed to the comparison function
2925support.detectDuplicates = !!hasDuplicate;
2926
2927// Initialize against the default document
2928setDocument();
2929
2930// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2931// Detached nodes confoundingly follow *each other*
2932support.sortDetached = assert( function( el ) {
2933
2934	// Should return 1, but returns 4 (following)
2935	return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
2936} );
2937
2938// Support: IE<8
2939// Prevent attribute/property "interpolation"
2940// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2941if ( !assert( function( el ) {
2942	el.innerHTML = "<a href='#'></a>";
2943	return el.firstChild.getAttribute( "href" ) === "#";
2944} ) ) {
2945	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2946		if ( !isXML ) {
2947			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2948		}
2949	} );
2950}
2951
2952// Support: IE<9
2953// Use defaultValue in place of getAttribute("value")
2954if ( !support.attributes || !assert( function( el ) {
2955	el.innerHTML = "<input/>";
2956	el.firstChild.setAttribute( "value", "" );
2957	return el.firstChild.getAttribute( "value" ) === "";
2958} ) ) {
2959	addHandle( "value", function( elem, _name, isXML ) {
2960		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2961			return elem.defaultValue;
2962		}
2963	} );
2964}
2965
2966// Support: IE<9
2967// Use getAttributeNode to fetch booleans when getAttribute lies
2968if ( !assert( function( el ) {
2969	return el.getAttribute( "disabled" ) == null;
2970} ) ) {
2971	addHandle( booleans, function( elem, name, isXML ) {
2972		var val;
2973		if ( !isXML ) {
2974			return elem[ name ] === true ? name.toLowerCase() :
2975				( val = elem.getAttributeNode( name ) ) && val.specified ?
2976					val.value :
2977					null;
2978		}
2979	} );
2980}
2981
2982return Sizzle;
2983
2984} )( window );
2985
2986
2987
2988jQuery.find = Sizzle;
2989jQuery.expr = Sizzle.selectors;
2990
2991// Deprecated
2992jQuery.expr[ ":" ] = jQuery.expr.pseudos;
2993jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2994jQuery.text = Sizzle.getText;
2995jQuery.isXMLDoc = Sizzle.isXML;
2996jQuery.contains = Sizzle.contains;
2997jQuery.escapeSelector = Sizzle.escape;
2998
2999
3000
3001
3002var dir = function( elem, dir, until ) {
3003	var matched = [],
3004		truncate = until !== undefined;
3005
3006	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
3007		if ( elem.nodeType === 1 ) {
3008			if ( truncate && jQuery( elem ).is( until ) ) {
3009				break;
3010			}
3011			matched.push( elem );
3012		}
3013	}
3014	return matched;
3015};
3016
3017
3018var siblings = function( n, elem ) {
3019	var matched = [];
3020
3021	for ( ; n; n = n.nextSibling ) {
3022		if ( n.nodeType === 1 && n !== elem ) {
3023			matched.push( n );
3024		}
3025	}
3026
3027	return matched;
3028};
3029
3030
3031var rneedsContext = jQuery.expr.match.needsContext;
3032
3033
3034
3035function nodeName( elem, name ) {
3036
3037	return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
3038
3039}
3040var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
3041
3042
3043
3044// Implement the identical functionality for filter and not
3045function winnow( elements, qualifier, not ) {
3046	if ( isFunction( qualifier ) ) {
3047		return jQuery.grep( elements, function( elem, i ) {
3048			return !!qualifier.call( elem, i, elem ) !== not;
3049		} );
3050	}
3051
3052	// Single element
3053	if ( qualifier.nodeType ) {
3054		return jQuery.grep( elements, function( elem ) {
3055			return ( elem === qualifier ) !== not;
3056		} );
3057	}
3058
3059	// Arraylike of elements (jQuery, arguments, Array)
3060	if ( typeof qualifier !== "string" ) {
3061		return jQuery.grep( elements, function( elem ) {
3062			return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
3063		} );
3064	}
3065
3066	// Filtered directly for both simple and complex selectors
3067	return jQuery.filter( qualifier, elements, not );
3068}
3069
3070jQuery.filter = function( expr, elems, not ) {
3071	var elem = elems[ 0 ];
3072
3073	if ( not ) {
3074		expr = ":not(" + expr + ")";
3075	}
3076
3077	if ( elems.length === 1 && elem.nodeType === 1 ) {
3078		return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
3079	}
3080
3081	return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
3082		return elem.nodeType === 1;
3083	} ) );
3084};
3085
3086jQuery.fn.extend( {
3087	find: function( selector ) {
3088		var i, ret,
3089			len = this.length,
3090			self = this;
3091
3092		if ( typeof selector !== "string" ) {