UNPKG

jquery/external/sizzle/dist/sizzle.js

Version:
73.3 kBJavaScriptView Raw
1/*!
* Sizzle CSS Selector Engine v2.3.9
* https://sizzlejs.com/
*
* Copyright JS Foundation and other contributors
* Released under the MIT license
* https://js.foundation/
*
* Date: 2022-12-19
*/
11( function( window ) {
12var i,
support,
Expr,
getText,
isXML,
tokenize,
compile,
select,
outermostContext,
sortInput,
hasDuplicate,
23
// Local document vars
setDocument,
document,
docElem,
documentIsHTML,
rbuggyQSA,
rbuggyMatches,
matches,
contains,
33
// Instance-specific data
expando = "sizzle" + 1 * new Date(),
preferredDoc = window.document,
dirruns = 0,
done = 0,
classCache = createCache(),
tokenCache = createCache(),
compilerCache = createCache(),
nonnativeSelectorCache = createCache(),
sortOrder = function( a, b ) {
if ( a === b ) {
	hasDuplicate = true;
}
return 0;
},
49
// Instance methods
hasOwn = ( {} ).hasOwnProperty,
arr = [],
pop = arr.pop,
pushNative = arr.push,
push = arr.push,
slice = arr.slice,
57
// Use a stripped-down indexOf as it's faster than native
// https://jsperf.com/thor-indexof-vs-for/5
indexOf = function( list, elem ) {
var i = 0,
	len = list.length;
for ( ; i < len; i++ ) {
	if ( list[ i ] === elem ) {
		return i;
	}
}
return -1;
},
70
booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
"ismap|loop|multiple|open|readonly|required|scoped",
73
// Regular expressions
75
// http://www.w3.org/TR/css3-selectors/#whitespace
whitespace = "[\\x20\\t\\r\\n\\f]",
78
// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
82
// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
85
// Operator (capture 2)
"*([*^$|!~]?=)" + whitespace +
88
// "Attribute values must be CSS identifiers [capture 5]
// or strings [capture 3 or capture 4]"
"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
whitespace + "*\\]",
93
pseudos = ":(" + identifier + ")(?:\\((" +
95
// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
// 1. quoted (capture 3; capture 4 or capture 5)
"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
99
// 2. simple (capture 6)
"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
102
// 3. anything else (capture 2)
".*" +
")\\)|)",
106
// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
rwhitespace = new RegExp( whitespace + "+", "g" ),
rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
whitespace + "+$", "g" ),
111
rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
"*" ),
rdescend = new RegExp( whitespace + "|>" ),
116
rpseudo = new RegExp( pseudos ),
ridentifier = new RegExp( "^" + identifier + "$" ),
119
matchExpr = {
"ID": new RegExp( "^#(" + identifier + ")" ),
"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
"TAG": new RegExp( "^(" + identifier + "|[*])" ),
"ATTR": new RegExp( "^" + attributes ),
"PSEUDO": new RegExp( "^" + pseudos ),
"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
	whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
	whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
130
// For use in libraries implementing .is()
// We use this for POS matching in `select`
"needsContext": new RegExp( "^" + whitespace +
	"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
	"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
},
137
rhtml = /HTML$/i,
rinputs = /^(?:input|select|textarea|button)$/i,
rheader = /^h\d$/i,
141
rnative = /^[^{]+\{\s*\[native \w/,
143
// Easily-parseable/retrievable ID or TAG or CLASS selectors
rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
146
rsibling = /[+~]/,
148
// CSS escapes
// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
funescape = function( escape, nonHex ) {
var high = "0x" + escape.slice( 1 ) - 0x10000;
154
return nonHex ?
156
	// Strip the backslash prefix from a non-hex escape sequence
	nonHex :
159
	// Replace a hexadecimal escape sequence with the encoded Unicode code point
	// Support: IE <=11+
	// For values outside the Basic Multilingual Plane (BMP), manually construct a
	// surrogate pair
	high < 0 ?
		String.fromCharCode( high + 0x10000 ) :
		String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
},
168
// CSS string/identifier serialization
// https://drafts.csswg.org/cssom/#common-serializing-idioms
rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
fcssescape = function( ch, asCodePoint ) {
if ( asCodePoint ) {
174
	// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
	if ( ch === "\0" ) {
		return "\uFFFD";
	}
179
	// Control characters and (dependent upon position) numbers get escaped as code points
	return ch.slice( 0, -1 ) + "\\" +
		ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
}
184
// Other potentially-special ASCII characters get backslash-escaped
return "\\" + ch;
},
188
// Used for iframes
// See setDocument()
// Removing the function wrapper causes a "Permission Denied"
// error in IE
unloadHandler = function() {
setDocument();
},
196
inDisabledFieldset = addCombinator(
function( elem ) {
	return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
},
{ dir: "parentNode", next: "legend" }
);
203
204// Optimize for push.apply( _, NodeList )
205try {
push.apply(
( arr = slice.call( preferredDoc.childNodes ) ),
preferredDoc.childNodes
);
210
// Support: Android<4.0
// Detect silently failing push.apply
// eslint-disable-next-line no-unused-expressions
arr[ preferredDoc.childNodes.length ].nodeType;
215} catch ( e ) {
push = { apply: arr.length ?
217
// Leverage slice if possible
function( target, els ) {
	pushNative.apply( target, slice.call( els ) );
} :
222
// Support: IE<9
// Otherwise append directly
function( target, els ) {
	var j = target.length,
		i = 0;
228
	// Can't trust NodeList.length
	while ( ( target[ j++ ] = els[ i++ ] ) ) {}
	target.length = j - 1;
}
};
234}
235
236function Sizzle( selector, context, results, seed ) {
var m, i, elem, nid, match, groups, newSelector,
newContext = context && context.ownerDocument,
239
// nodeType defaults to 9, since context defaults to document
nodeType = context ? context.nodeType : 9;
242
results = results || [];
244
// Return early from calls with invalid selector or context
if ( typeof selector !== "string" || !selector ||
nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
248
return results;
}
251
// Try to shortcut find operations (as opposed to filters) in HTML documents
if ( !seed ) {
setDocument( context );
context = context || document;
256
if ( documentIsHTML ) {
258
	// If the selector is sufficiently simple, try using a "get*By*" DOM method
	// (excepting DocumentFragment context, where the methods don't exist)
	if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
262
		// ID selector
		if ( ( m = match[ 1 ] ) ) {
265
			// Document context
			if ( nodeType === 9 ) {
				if ( ( elem = context.getElementById( m ) ) ) {
269
					// Support: IE, Opera, Webkit
					// TODO: identify versions
					// getElementById can match elements by name instead of ID
					if ( elem.id === m ) {
						results.push( elem );
						return results;
					}
				} else {
					return results;
				}
280
			// Element context
			} else {
283
				// Support: IE, Opera, Webkit
				// TODO: identify versions
				// getElementById can match elements by name instead of ID
				if ( newContext && ( elem = newContext.getElementById( m ) ) &&
					contains( context, elem ) &&
					elem.id === m ) {
290
					results.push( elem );
					return results;
				}
			}
295
		// Type selector
		} else if ( match[ 2 ] ) {
			push.apply( results, context.getElementsByTagName( selector ) );
			return results;
300
		// Class selector
		} else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&
			context.getElementsByClassName ) {
304
			push.apply( results, context.getElementsByClassName( m ) );
			return results;
		}
	}
309
	// Take advantage of querySelectorAll
	if ( support.qsa &&
		!nonnativeSelectorCache[ selector + " " ] &&
		( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&
314
		// Support: IE 8 only
		// Exclude object elements
		( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) {
318
		newSelector = selector;
		newContext = context;
321
		// qSA considers elements outside a scoping root when evaluating child or
		// descendant combinators, which is not what we want.
		// In such cases, we work around the behavior by prefixing every selector in the
		// list with an ID selector referencing the scope context.
		// The technique has to be used as well when a leading combinator is used
		// as such selectors are not recognized by querySelectorAll.
		// Thanks to Andrew Dupont for this technique.
		if ( nodeType === 1 &&
			( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
331
			// Expand context for sibling selectors
			newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
				context;
335
			// We can use :scope instead of the ID hack if the browser
			// supports it & if we're not changing the context.
			if ( newContext !== context || !support.scope ) {
339
				// Capture the context ID, setting it first if necessary
				if ( ( nid = context.getAttribute( "id" ) ) ) {
					nid = nid.replace( rcssescape, fcssescape );
				} else {
					context.setAttribute( "id", ( nid = expando ) );
				}
			}
347
			// Prefix every selector in the list
			groups = tokenize( selector );
			i = groups.length;
			while ( i-- ) {
				groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
					toSelector( groups[ i ] );
			}
			newSelector = groups.join( "," );
		}
357
		try {
359
			// `qSA` may not throw for unrecognized parts using forgiving parsing:
			// https://drafts.csswg.org/selectors/#forgiving-selector
			// like the `:has()` pseudo-class:
			// https://drafts.csswg.org/selectors/#relational
			// `CSS.supports` is still expected to return `false` then:
			// https://drafts.csswg.org/css-conditional-4/#typedef-supports-selector-fn
			// https://drafts.csswg.org/css-conditional-4/#dfn-support-selector
			if ( support.cssSupportsSelector &&
368
				// eslint-disable-next-line no-undef
				!CSS.supports( "selector(:is(" + newSelector + "))" ) ) {
371
				// Support: IE 11+
				// Throw to get to the same code path as an error directly in qSA.
				// Note: once we only support browser supporting
				// `CSS.supports('selector(...)')`, we can most likely drop
				// the `try-catch`. IE doesn't implement the API.
				throw new Error();
			}
379
			push.apply( results,
				newContext.querySelectorAll( newSelector )
			);
			return results;
		} catch ( qsaError ) {
			nonnativeSelectorCache( selector, true );
		} finally {
			if ( nid === expando ) {
				context.removeAttribute( "id" );
			}
		}
	}
}
}
394
// All others
return select( selector.replace( rtrim, "$1" ), context, results, seed );
397}
398
399/**
* Create key-value caches of limited size
* @returns {function(string, object)} Returns the Object data after storing it on itself with
*	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
*	deleting the oldest entry
*/
405function createCache() {
var keys = [];
407
function cache( key, value ) {
409
// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
if ( keys.push( key + " " ) > Expr.cacheLength ) {
412
	// Only keep the most recent entries
	delete cache[ keys.shift() ];
}
return ( cache[ key + " " ] = value );
}
return cache;
419}
420
421/**
* Mark a function for special use by Sizzle
* @param {Function} fn The function to mark
*/
425function markFunction( fn ) {
fn[ expando ] = true;
return fn;
428}
429
430/**
* Support testing using an element
* @param {Function} fn Passed the created element and returns a boolean result
*/
434function assert( fn ) {
var el = document.createElement( "fieldset" );
436
try {
return !!fn( el );
} catch ( e ) {
return false;
} finally {
442
// Remove from its parent by default
if ( el.parentNode ) {
	el.parentNode.removeChild( el );
}
447
// release memory in IE
el = null;
}
451}
452
453/**
* Adds the same handler for all of the specified attrs
* @param {String} attrs Pipe-separated list of attributes
* @param {Function} handler The method that will be applied
*/
458function addHandle( attrs, handler ) {
var arr = attrs.split( "|" ),
i = arr.length;
461
while ( i-- ) {
Expr.attrHandle[ arr[ i ] ] = handler;
}
465}
466
467/**
* Checks document order of two siblings
* @param {Element} a
* @param {Element} b
* @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
*/
473function siblingCheck( a, b ) {
var cur = b && a,
diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
	a.sourceIndex - b.sourceIndex;
477
// Use IE sourceIndex if available on both nodes
if ( diff ) {
return diff;
}
482
// Check if b follows a
if ( cur ) {
while ( ( cur = cur.nextSibling ) ) {
	if ( cur === b ) {
		return -1;
	}
}
}
491
return a ? 1 : -1;
493}
494
495/**
* Returns a function to use in pseudos for input types
* @param {String} type
*/
499function createInputPseudo( type ) {
return function( elem ) {
var name = elem.nodeName.toLowerCase();
return name === "input" && elem.type === type;
};
504}
505
506/**
* Returns a function to use in pseudos for buttons
* @param {String} type
*/
510function createButtonPseudo( type ) {
return function( elem ) {
var name = elem.nodeName.toLowerCase();
return ( name === "input" || name === "button" ) && elem.type === type;
};
515}
516
517/**
* Returns a function to use in pseudos for :enabled/:disabled
* @param {Boolean} disabled true for :disabled; false for :enabled
*/
521function createDisabledPseudo( disabled ) {
522
// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
return function( elem ) {
525
// Only certain elements can match :enabled or :disabled
// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
if ( "form" in elem ) {
530
	// Check for inherited disabledness on relevant non-disabled elements:
	// * listed form-associated elements in a disabled fieldset
	//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
	//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
	// * option elements in a disabled optgroup
	//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
	// All such elements have a "form" property.
	if ( elem.parentNode && elem.disabled === false ) {
539
		// Option elements defer to a parent optgroup if present
		if ( "label" in elem ) {
			if ( "label" in elem.parentNode ) {
				return elem.parentNode.disabled === disabled;
			} else {
				return elem.disabled === disabled;
			}
		}
548
		// Support: IE 6 - 11
		// Use the isDisabled shortcut property to check for disabled fieldset ancestors
		return elem.isDisabled === disabled ||
552
			// Where there is no isDisabled, check manually
			/* jshint -W018 */
			elem.isDisabled !== !disabled &&
			inDisabledFieldset( elem ) === disabled;
	}
558
	return elem.disabled === disabled;
560
// Try to winnow out elements that can't be disabled before trusting the disabled property.
// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
// even exist on them, let alone have a boolean value.
} else if ( "label" in elem ) {
	return elem.disabled === disabled;
}
567
// Remaining elements are neither :enabled nor :disabled
return false;
};
571}
572
573/**
* Returns a function to use in pseudos for positionals
* @param {Function} fn
*/
577function createPositionalPseudo( fn ) {
return markFunction( function( argument ) {
argument = +argument;
return markFunction( function( seed, matches ) {
	var j,
		matchIndexes = fn( [], seed.length, argument ),
		i = matchIndexes.length;
584
	// Match elements found at the specified indexes
	while ( i-- ) {
		if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
			seed[ j ] = !( matches[ j ] = seed[ j ] );
		}
	}
} );
} );
593}
594
595/**
* Checks a node for validity as a Sizzle context
* @param {Element|Object=} context
* @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
*/
600function testContext( context ) {
return context && typeof context.getElementsByTagName !== "undefined" && context;
602}
603
604// Expose support vars for convenience
605support = Sizzle.support = {};
606
607/**
* Detects XML nodes
* @param {Element|Object} elem An element or a document
* @returns {Boolean} True iff elem is a non-HTML XML node
*/
612isXML = Sizzle.isXML = function( elem ) {
var namespace = elem && elem.namespaceURI,
docElem = elem && ( elem.ownerDocument || elem ).documentElement;
615
// Support: IE <=8
// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
// https://bugs.jquery.com/ticket/4833
return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
620};
621
622/**
* Sets document-related variables once based on the current document
* @param {Element|Object} [doc] An element or document object to use to set the document
* @returns {Object} Returns the current document
*/
627setDocument = Sizzle.setDocument = function( node ) {
var hasCompare, subWindow,
doc = node ? node.ownerDocument || node : preferredDoc;
630
// Return early if doc is invalid or already selected
// Support: IE 11+, Edge 17 - 18+
// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
// two documents; shallow comparisons work.
// eslint-disable-next-line eqeqeq
if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
return document;
}
639
// Update global variables
document = doc;
docElem = document.documentElement;
documentIsHTML = !isXML( document );
644
// Support: IE 9 - 11+, Edge 12 - 18+
// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
// Support: IE 11+, Edge 17 - 18+
// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
// two documents; shallow comparisons work.
// eslint-disable-next-line eqeqeq
if ( preferredDoc != document &&
( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
653
// Support: IE 11, Edge
if ( subWindow.addEventListener ) {
	subWindow.addEventListener( "unload", unloadHandler, false );
657
// Support: IE 9 - 10 only
} else if ( subWindow.attachEvent ) {
	subWindow.attachEvent( "onunload", unloadHandler );
}
}
663
// Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,
// Safari 4 - 5 only, Opera <=11.6 - 12.x only
// IE/Edge & older browsers don't support the :scope pseudo-class.
// Support: Safari 6.0 only
// Safari 6.0 supports :scope but it's an alias of :root there.
support.scope = assert( function( el ) {
docElem.appendChild( el ).appendChild( document.createElement( "div" ) );
return typeof el.querySelectorAll !== "undefined" &&
	!el.querySelectorAll( ":scope fieldset div" ).length;
} );
674
// Support: Chrome 105+, Firefox 104+, Safari 15.4+
// Make sure forgiving mode is not used in `CSS.supports( "selector(...)" )`.
//
// `:is()` uses a forgiving selector list as an argument and is widely
// implemented, so it's a good one to test against.
support.cssSupportsSelector = assert( function() {
/* eslint-disable no-undef */
682
return CSS.supports( "selector(*)" ) &&
684
	// Support: Firefox 78-81 only
	// In old Firefox, `:is()` didn't use forgiving parsing. In that case,
	// fail this test as there's no selector to test against that.
	// `CSS.supports` uses unforgiving parsing
	document.querySelectorAll( ":is(:jqfake)" ) &&
690
	// `*` is needed as Safari & newer Chrome implemented something in between
	// for `:has()` - it throws in `qSA` if it only contains an unsupported
	// argument but multiple ones, one of which is supported, are fine.
	// We want to play safe in case `:is()` gets the same treatment.
	!CSS.supports( "selector(:is(*,:jqfake))" );
696
/* eslint-enable */
} );
699
/* Attributes
---------------------------------------------------------------------- */
702
// Support: IE<8
// Verify that getAttribute really returns attributes and not properties
// (excepting IE8 booleans)
support.attributes = assert( function( el ) {
el.className = "i";
return !el.getAttribute( "className" );
} );
710
/* getElement(s)By*
---------------------------------------------------------------------- */
713
// Check if getElementsByTagName("*") returns only elements
support.getElementsByTagName = assert( function( el ) {
el.appendChild( document.createComment( "" ) );
return !el.getElementsByTagName( "*" ).length;
} );
719
// Support: IE<9
support.getElementsByClassName = rnative.test( document.getElementsByClassName );
722
// Support: IE<10
// Check if getElementById returns elements by name
// The broken getElementById methods don't pick up programmatically-set names,
// so use a roundabout getElementsByName test
support.getById = assert( function( el ) {
docElem.appendChild( el ).id = expando;
return !document.getElementsByName || !document.getElementsByName( expando ).length;
} );
731
// ID filter and find
if ( support.getById ) {
Expr.filter[ "ID" ] = function( id ) {
	var attrId = id.replace( runescape, funescape );
	return function( elem ) {
		return elem.getAttribute( "id" ) === attrId;
	};
};
Expr.find[ "ID" ] = function( id, context ) {
	if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
		var elem = context.getElementById( id );
		return elem ? [ elem ] : [];
	}
};
} else {
Expr.filter[ "ID" ] =  function( id ) {
	var attrId = id.replace( runescape, funescape );
	return function( elem ) {
		var node = typeof elem.getAttributeNode !== "undefined" &&
			elem.getAttributeNode( "id" );
		return node && node.value === attrId;
	};
};
755
// Support: IE 6 - 7 only
// getElementById is not reliable as a find shortcut
Expr.find[ "ID" ] = function( id, context ) {
	if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
		var node, i, elems,
			elem = context.getElementById( id );
762
		if ( elem ) {
764
			// Verify the id attribute
			node = elem.getAttributeNode( "id" );
			if ( node && node.value === id ) {
				return [ elem ];
			}
770
			// Fall back on getElementsByName
			elems = context.getElementsByName( id );
			i = 0;
			while ( ( elem = elems[ i++ ] ) ) {
				node = elem.getAttributeNode( "id" );
				if ( node && node.value === id ) {
					return [ elem ];
				}
			}
		}
781
		return [];
	}
};
}
786
// Tag
Expr.find[ "TAG" ] = support.getElementsByTagName ?
function( tag, context ) {
	if ( typeof context.getElementsByTagName !== "undefined" ) {
		return context.getElementsByTagName( tag );
792
	// DocumentFragment nodes don't have gEBTN
	} else if ( support.qsa ) {
		return context.querySelectorAll( tag );
	}
} :
798
function( tag, context ) {
	var elem,
		tmp = [],
		i = 0,
803
		// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
		results = context.getElementsByTagName( tag );
806
	// Filter out possible comments
	if ( tag === "*" ) {
		while ( ( elem = results[ i++ ] ) ) {
			if ( elem.nodeType === 1 ) {
				tmp.push( elem );
			}
		}
814
		return tmp;
	}
	return results;
};
819
// Class
Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) {
if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
	return context.getElementsByClassName( className );
}
};
826
/* QSA/matchesSelector
---------------------------------------------------------------------- */
829
// QSA and matchesSelector support
831
// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
rbuggyMatches = [];
834
// qSa(:focus) reports false when true (Chrome 21)
// We allow this because of a bug in IE8/9 that throws an error
// whenever `document.activeElement` is accessed on an iframe
// So, we allow :focus to pass through QSA all the time to avoid the IE error
// See https://bugs.jquery.com/ticket/13378
rbuggyQSA = [];
841
if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {
843
// Build QSA regex
// Regex strategy adopted from Diego Perini
assert( function( el ) {
847
	var input;
849
	// Select is set to empty string on purpose
	// This is to test IE's treatment of not explicitly
	// setting a boolean content attribute,
	// since its presence should be enough
	// https://bugs.jquery.com/ticket/12359
	docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
		"<select id='" + expando + "-\r\\' msallowcapture=''>" +
		"<option selected=''></option></select>";
858
	// Support: IE8, Opera 11-12.16
	// Nothing should be selected when empty strings follow ^= or $= or *=
	// The test attribute must be unknown in Opera but "safe" for WinRT
	// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
	if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) {
		rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
	}
866
	// Support: IE8
	// Boolean attributes and "value" are not treated correctly
	if ( !el.querySelectorAll( "[selected]" ).length ) {
		rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
	}
872
	// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
	if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
		rbuggyQSA.push( "~=" );
	}
877
	// Support: IE 11+, Edge 15 - 18+
	// IE 11/Edge don't find elements on a `[name='']` query in some cases.
	// Adding a temporary attribute to the document before the selection works
	// around the issue.
	// Interestingly, IE 10 & older don't seem to have the issue.
	input = document.createElement( "input" );
	input.setAttribute( "name", "" );
	el.appendChild( input );
	if ( !el.querySelectorAll( "[name='']" ).length ) {
		rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
			whitespace + "*(?:''|\"\")" );
	}
890
	// Webkit/Opera - :checked should return selected option elements
	// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
	// IE8 throws error here and will not see later tests
	if ( !el.querySelectorAll( ":checked" ).length ) {
		rbuggyQSA.push( ":checked" );
	}
897
	// Support: Safari 8+, iOS 8+
	// https://bugs.webkit.org/show_bug.cgi?id=136851
	// In-page `selector#id sibling-combinator selector` fails
	if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
		rbuggyQSA.push( ".#.+[+~]" );
	}
904
	// Support: Firefox <=3.6 - 5 only
	// Old Firefox doesn't throw on a badly-escaped identifier.
	el.querySelectorAll( "\\\f" );
	rbuggyQSA.push( "[\\r\\n\\f]" );
} );
910
assert( function( el ) {
	el.innerHTML = "<a href='' disabled='disabled'></a>" +
		"<select disabled='disabled'><option/></select>";
914
	// Support: Windows 8 Native Apps
	// The type and name attributes are restricted during .innerHTML assignment
	var input = document.createElement( "input" );
	input.setAttribute( "type", "hidden" );
	el.appendChild( input ).setAttribute( "name", "D" );
920
	// Support: IE8
	// Enforce case-sensitivity of name attribute
	if ( el.querySelectorAll( "[name=d]" ).length ) {
		rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
	}
926
	// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
	// IE8 throws error here and will not see later tests
	if ( el.querySelectorAll( ":enabled" ).length !== 2 ) {
		rbuggyQSA.push( ":enabled", ":disabled" );
	}
932
	// Support: IE9-11+
	// IE's :disabled selector does not pick up the children of disabled fieldsets
	docElem.appendChild( el ).disabled = true;
	if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
		rbuggyQSA.push( ":enabled", ":disabled" );
	}
939
	// Support: Opera 10 - 11 only
	// Opera 10-11 does not throw on post-comma invalid pseudos
	el.querySelectorAll( "*,:x" );
	rbuggyQSA.push( ",.*:" );
} );
}
946
if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||
docElem.webkitMatchesSelector ||
docElem.mozMatchesSelector ||
docElem.oMatchesSelector ||
docElem.msMatchesSelector ) ) ) ) {
952
assert( function( el ) {
954
	// Check to see if it's possible to do matchesSelector
	// on a disconnected node (IE 9)
	support.disconnectedMatch = matches.call( el, "*" );
958
	// This should fail with an exception
	// Gecko does not error, returns false instead
	matches.call( el, "[s!='']:x" );
	rbuggyMatches.push( "!=", pseudos );
} );
}
965
if ( !support.cssSupportsSelector ) {
967
// Support: Chrome 105+, Safari 15.4+
// `:has()` uses a forgiving selector list as an argument so our regular
// `try-catch` mechanism fails to catch `:has()` with arguments not supported
// natively like `:has(:contains("Foo"))`. Where supported & spec-compliant,
// we now use `CSS.supports("selector(:is(SELECTOR_TO_BE_TESTED))")`, but
// outside that we mark `:has` as buggy.
rbuggyQSA.push( ":has" );
}
976
rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) );
979
/* Contains
---------------------------------------------------------------------- */
hasCompare = rnative.test( docElem.compareDocumentPosition );
983
// Element contains another
// Purposefully self-exclusive
// As in, an element does not contain itself
contains = hasCompare || rnative.test( docElem.contains ) ?
function( a, b ) {
989
	// Support: IE <9 only
	// IE doesn't have `contains` on `document` so we need to check for
	// `documentElement` presence.
	// We need to fall back to `a` when `documentElement` is missing
	// as `ownerDocument` of elements within `<template/>` may have
	// a null one - a default behavior of all modern browsers.
	var adown = a.nodeType === 9 && a.documentElement || a,
		bup = b && b.parentNode;
	return a === bup || !!( bup && bup.nodeType === 1 && (
		adown.contains ?
			adown.contains( bup ) :
			a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
	) );
} :
function( a, b ) {
	if ( b ) {
		while ( ( b = b.parentNode ) ) {
			if ( b === a ) {
				return true;
			}
		}
	}
	return false;
};
1014
/* Sorting
---------------------------------------------------------------------- */
1017
// Document order sorting
sortOrder = hasCompare ?
function( a, b ) {
1021
// Flag for duplicate removal
if ( a === b ) {
	hasDuplicate = true;
	return 0;
}
1027
// Sort on method existence if only one input has compareDocumentPosition
var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
if ( compare ) {
	return compare;
}
1033
// Calculate position if both inputs belong to the same document
// Support: IE 11+, Edge 17 - 18+
// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
// two documents; shallow comparisons work.
// eslint-disable-next-line eqeqeq
compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
	a.compareDocumentPosition( b ) :
1041
	// Otherwise we know they are disconnected
	1;
1044
// Disconnected nodes
if ( compare & 1 ||
	( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {
1048
	// Choose the first element that is related to our preferred document
	// Support: IE 11+, Edge 17 - 18+
	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
	// two documents; shallow comparisons work.
	// eslint-disable-next-line eqeqeq
	if ( a == document || a.ownerDocument == preferredDoc &&
		contains( preferredDoc, a ) ) {
		return -1;
	}
1058
	// Support: IE 11+, Edge 17 - 18+
	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
	// two documents; shallow comparisons work.
	// eslint-disable-next-line eqeqeq
	if ( b == document || b.ownerDocument == preferredDoc &&
		contains( preferredDoc, b ) ) {
		return 1;
	}
1067
	// Maintain original order
	return sortInput ?
		( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
		0;
}
1073
return compare & 4 ? -1 : 1;
} :
function( a, b ) {
1077
// Exit early if the nodes are identical
if ( a === b ) {
	hasDuplicate = true;
	return 0;
}
1083
var cur,
	i = 0,
	aup = a.parentNode,
	bup = b.parentNode,
	ap = [ a ],
	bp = [ b ];
1090
// Parentless nodes are either documents or disconnected
if ( !aup || !bup ) {
1093
	// Support: IE 11+, Edge 17 - 18+
	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
	// two documents; shallow comparisons work.
	/* eslint-disable eqeqeq */
	return a == document ? -1 :
		b == document ? 1 :
		/* eslint-enable eqeqeq */
		aup ? -1 :
		bup ? 1 :
		sortInput ?
		( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
		0;
1106
// If the nodes are siblings, we can do a quick check
} else if ( aup === bup ) {
	return siblingCheck( a, b );
}
1111
// Otherwise we need full lists of their ancestors for comparison
cur = a;
while ( ( cur = cur.parentNode ) ) {
	ap.unshift( cur );
}
cur = b;
while ( ( cur = cur.parentNode ) ) {
	bp.unshift( cur );
}
1121
// Walk down the tree looking for a discrepancy
while ( ap[ i ] === bp[ i ] ) {
	i++;
}
1126
return i ?
1128
	// Do a sibling check if the nodes have a common ancestor
	siblingCheck( ap[ i ], bp[ i ] ) :
1131
	// Otherwise nodes in our document sort first
	// Support: IE 11+, Edge 17 - 18+
	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
	// two documents; shallow comparisons work.
	/* eslint-disable eqeqeq */
	ap[ i ] == preferredDoc ? -1 :
	bp[ i ] == preferredDoc ? 1 :
	/* eslint-enable eqeqeq */
	0;
};
1142
return document;
1144};
1145
1146Sizzle.matches = function( expr, elements ) {
return Sizzle( expr, null, null, elements );
1148};
1149
1150Sizzle.matchesSelector = function( elem, expr ) {
setDocument( elem );
1152
if ( support.matchesSelector && documentIsHTML &&
!nonnativeSelectorCache[ expr + " " ] &&
( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1157
try {
	var ret = matches.call( elem, expr );
1160
	// IE 9's matchesSelector returns false on disconnected nodes
	if ( ret || support.disconnectedMatch ||
1163
		// As well, disconnected nodes are said to be in a document
		// fragment in IE 9
		elem.document && elem.document.nodeType !== 11 ) {
		return ret;
	}
} catch ( e ) {
	nonnativeSelectorCache( expr, true );
}
}
1173
return Sizzle( expr, document, null, [ elem ] ).length > 0;
1175};
1176
1177Sizzle.contains = function( context, elem ) {
1178
// Set document vars if needed
// Support: IE 11+, Edge 17 - 18+
// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
// two documents; shallow comparisons work.
// eslint-disable-next-line eqeqeq
if ( ( context.ownerDocument || context ) != document ) {
setDocument( context );
}
return contains( context, elem );
1188};
1189
1190Sizzle.attr = function( elem, name ) {
1191
// Set document vars if needed
// Support: IE 11+, Edge 17 - 18+
// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
// two documents; shallow comparisons work.
// eslint-disable-next-line eqeqeq
if ( ( elem.ownerDocument || elem ) != document ) {
setDocument( elem );
}
1200
var fn = Expr.attrHandle[ name.toLowerCase() ],
1202
// Don't get fooled by Object.prototype properties (jQuery #13807)
val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
	fn( elem, name, !documentIsHTML ) :
	undefined;
1207
return val !== undefined ?
val :
support.attributes || !documentIsHTML ?
	elem.getAttribute( name ) :
	( val = elem.getAttributeNode( name ) ) && val.specified ?
		val.value :
		null;
1215};
1216
1217Sizzle.escape = function( sel ) {
return ( sel + "" ).replace( rcssescape, fcssescape );
1219};
1220
1221Sizzle.error = function( msg ) {
throw new Error( "Syntax error, unrecognized expression: " + msg );
1223};
1224
1225/**
* Document sorting and removing duplicates
* @param {ArrayLike} results
*/
1229Sizzle.uniqueSort = function( results ) {
var elem,
duplicates = [],
j = 0,
i = 0;
1234
// Unless we *know* we can detect duplicates, assume their presence
hasDuplicate = !support.detectDuplicates;
sortInput = !support.sortStable && results.slice( 0 );
results.sort( sortOrder );
1239
if ( hasDuplicate ) {
while ( ( elem = results[ i++ ] ) ) {
	if ( elem === results[ i ] ) {
		j = duplicates.push( i );
	}
}
while ( j-- ) {
	results.splice( duplicates[ j ], 1 );
}
}
1250
// Clear input after sorting to release objects
// See https://github.com/jquery/sizzle/pull/225
sortInput = null;
1254
return results;
1256};
1257
1258/**
* Utility function for retrieving the text value of an array of DOM nodes
* @param {Array|Element} elem
*/
1262getText = Sizzle.getText = function( elem ) {
var node,
ret = "",
i = 0,
nodeType = elem.nodeType;
1267
if ( !nodeType ) {
1269
// If no nodeType, this is expected to be an array
while ( ( node = elem[ i++ ] ) ) {
1272
	// Do not traverse comment nodes
	ret += getText( node );
}
} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1277
// Use textContent for elements
// innerText usage removed for consistency of new lines (jQuery #11153)
if ( typeof elem.textContent === "string" ) {
	return elem.textContent;
} else {
1283
	// Traverse its children
	for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
		ret += getText( elem );
	}
}
} else if ( nodeType === 3 || nodeType === 4 ) {
return elem.nodeValue;
}
1292
// Do not include comment or processing instruction nodes
1294
return ret;
1296};
1297
1298Expr = Sizzle.selectors = {
1299
// Can be adjusted by the user
cacheLength: 50,
1302
createPseudo: markFunction,
1304
match: matchExpr,
1306
attrHandle: {},
1308
find: {},
1310
relative: {
">": { dir: "parentNode", first: true },
" ": { dir: "parentNode" },
"+": { dir: "previousSibling", first: true },
"~": { dir: "previousSibling" }
},
1317
preFilter: {
"ATTR": function( match ) {
	match[ 1 ] = match[ 1 ].replace( runescape, funescape );
1321
	// Move the given value to match[3] whether quoted or unquoted
	match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||
		match[ 5 ] || "" ).replace( runescape, funescape );
1325
	if ( match[ 2 ] === "~=" ) {
		match[ 3 ] = " " + match[ 3 ] + " ";
	}
1329
	return match.slice( 0, 4 );
},
1332
"CHILD": function( match ) {
1334
	/* matches from matchExpr["CHILD"]
		1 type (only|nth|...)
		2 what (child|of-type)
		3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
		4 xn-component of xn+y argument ([+-]?\d*n|)
		5 sign of xn-component
		6 x of xn-component
		7 sign of y-component
		8 y of y-component
	*/
	match[ 1 ] = match[ 1 ].toLowerCase();
1346
	if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
1348
		// nth-* requires argument
		if ( !match[ 3 ] ) {
			Sizzle.error( match[ 0 ] );
		}
1353
		// numeric x and y parameters for Expr.filter.CHILD
		// remember that false/true cast respectively to 0/1
		match[ 4 ] = +( match[ 4 ] ?
			match[ 5 ] + ( match[ 6 ] || 1 ) :
			2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) );
		match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
1360
		// other types prohibit arguments
	} else if ( match[ 3 ] ) {
		Sizzle.error( match[ 0 ] );
	}
1365
	return match;
},
1368
"PSEUDO": function( match ) {
	var excess,
		unquoted = !match[ 6 ] && match[ 2 ];
1372
	if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) {
		return null;
	}
1376
	// Accept quoted arguments as-is
	if ( match[ 3 ] ) {
		match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
1380
	// Strip excess characters from unquoted arguments
	} else if ( unquoted && rpseudo.test( unquoted ) &&
1383
		// Get excess from tokenize (recursively)
		( excess = tokenize( unquoted, true ) ) &&
1386
		// advance to the next closing parenthesis
		( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
1389
		// excess is a negative index
		match[ 0 ] = match[ 0 ].slice( 0, excess );
		match[ 2 ] = unquoted.slice( 0, excess );
	}
1394
	// Return only captures needed by the pseudo filter method (type and argument)
	return match.slice( 0, 3 );
}
},
1399
filter: {
1401
"TAG": function( nodeNameSelector ) {
	var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
	return nodeNameSelector === "*" ?
		function() {
			return true;
		} :
		function( elem ) {
			return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
		};
},
1412
"CLASS": function( className ) {
	var pattern = classCache[ className + " " ];
1415
	return pattern ||
		( pattern = new RegExp( "(^|" + whitespace +
			")" + className + "(" + whitespace + "|$)" ) ) && classCache(
				className, function( elem ) {
					return pattern.test(
						typeof elem.className === "string" && elem.className ||
						typeof elem.getAttribute !== "undefined" &&
							elem.getAttribute( "class" ) ||
						""
					);
		} );
},
1428
"ATTR": function( name, operator, check ) {
	return function( elem ) {
		var result = Sizzle.attr( elem, name );
1432
		if ( result == null ) {
			return operator === "!=";
		}
		if ( !operator ) {
			return true;
		}
1439
		result += "";
1441
		/* eslint-disable max-len */
1443
		return operator === "=" ? result === check :
			operator === "!=" ? result !== check :
			operator === "^=" ? check && result.indexOf( check ) === 0 :
			operator === "*=" ? check && result.indexOf( check ) > -1 :
			operator === "$=" ? check && result.slice( -check.length ) === check :
			operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
			operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
			false;
		/* eslint-enable max-len */
1453
	};
},
1456
"CHILD": function( type, what, _argument, first, last ) {
	var simple = type.slice( 0, 3 ) !== "nth",
		forward = type.slice( -4 ) !== "last",
		ofType = what === "of-type";
1461
	return first === 1 && last === 0 ?
1463
		// Shortcut for :nth-*(n)
		function( elem ) {
			return !!elem.parentNode;
		} :
1468
		function( elem, _context, xml ) {
			var cache, uniqueCache, outerCache, node, nodeIndex, start,
				dir = simple !== forward ? "nextSibling" : "previousSibling",
				parent = elem.parentNode,
				name = ofType && elem.nodeName.toLowerCase(),
				useCache = !xml && !ofType,
				diff = false;
1476
			if ( parent ) {
1478
				// :(first|last|only)-(child|of-type)
				if ( simple ) {
					while ( dir ) {
						node = elem;
						while ( ( node = node[ dir ] ) ) {
							if ( ofType ?
								node.nodeName.toLowerCase() === name :
								node.nodeType === 1 ) {
1487
								return false;
							}
						}
1491
						// Reverse direction for :only-* (if we haven't yet done so)
						start = dir = type === "only" && !start && "nextSibling";
					}
					return true;
				}
1497
				start = [ forward ? parent.firstChild : parent.lastChild ];
1499
				// non-xml :nth-child(...) stores cache data on `parent`
				if ( forward && useCache ) {
1502
					// Seek `elem` from a previously-cached index
1504
					// ...in a gzip-friendly way
					node = parent;
					outerCache = node[ expando ] || ( node[ expando ] = {} );
1508
					// Support: IE <9 only
					// Defend against cloned attroperties (jQuery gh-1709)
					uniqueCache = outerCache[ node.uniqueID ] ||
						( outerCache[ node.uniqueID ] = {} );
1513
					cache = uniqueCache[ type ] || [];
					nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
					diff = nodeIndex && cache[ 2 ];
					node = nodeIndex && parent.childNodes[ nodeIndex ];
1518
					while ( ( node = ++nodeIndex && node && node[ dir ] ||
1520
						// Fallback to seeking `elem` from the start
						( diff = nodeIndex = 0 ) || start.pop() ) ) {
1523
						// When found, cache indexes on `parent` and break
						if ( node.nodeType === 1 && ++diff && node === elem ) {
							uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
							break;
						}
					}
1530
				} else {
1532
					// Use previously-cached element index if available
					if ( useCache ) {
1535
						// ...in a gzip-friendly way
						node = elem;
						outerCache = node[ expando ] || ( node[ expando ] = {} );
1539
						// Support: IE <9 only
						// Defend against cloned attroperties (jQuery gh-1709)
						uniqueCache = outerCache[ node.uniqueID ] ||
							( outerCache[ node.uniqueID ] = {} );
1544
						cache = uniqueCache[ type ] || [];
						nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
						diff = nodeIndex;
					}
1549
					// xml :nth-child(...)
					// or :nth-last-child(...) or :nth(-last)?-of-type(...)
					if ( diff === false ) {
1553
						// Use the same loop as above to seek `elem` from the start
						while ( ( node = ++nodeIndex && node && node[ dir ] ||
							( diff = nodeIndex = 0 ) || start.pop() ) ) {
1557
							if ( ( ofType ?
								node.nodeName.toLowerCase() === name :
								node.nodeType === 1 ) &&
								++diff ) {
1562
								// Cache the index of each encountered element
								if ( useCache ) {
									outerCache = node[ expando ] ||
										( node[ expando ] = {} );
1567
									// Support: IE <9 only
									// Defend against cloned attroperties (jQuery gh-1709)
									uniqueCache = outerCache[ node.uniqueID ] ||
										( outerCache[ node.uniqueID ] = {} );
1572
									uniqueCache[ type ] = [ dirruns, diff ];
								}
1575
								if ( node === elem ) {
									break;
								}
							}
						}
					}
				}
1583
				// Incorporate the offset, then check against cycle size
				diff -= last;
				return diff === first || ( diff % first === 0 && diff / first >= 0 );
			}
		};
},
1590
"PSEUDO": function( pseudo, argument ) {
1592
	// pseudo-class names are case-insensitive
	// http://www.w3.org/TR/selectors/#pseudo-classes
	// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
	// Remember that setFilters inherits from pseudos
	var args,
		fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
			Sizzle.error( "unsupported pseudo: " + pseudo );
1600
	// The user may use createPseudo to indicate that
	// arguments are needed to create the filter function
	// just as Sizzle does
	if ( fn[ expando ] ) {
		return fn( argument );
	}
1607
	// But maintain support for old signatures
	if ( fn.length > 1 ) {
		args = [ pseudo, pseudo, "", argument ];
		return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
			markFunction( function( seed, matches ) {
				var idx,
					matched = fn( seed, argument ),
					i = matched.length;
				while ( i-- ) {
					idx = indexOf( seed, matched[ i ] );
					seed[ idx ] = !( matches[ idx ] = matched[ i ] );
				}
			} ) :
			function( elem ) {
				return fn( elem, 0, args );
			};
	}
1625
	return fn;
}
},
1629
pseudos: {
1631
// Potentially complex pseudos
"not": markFunction( function( selector ) {
1634
	// Trim the selector passed to compile
	// to avoid treating leading and trailing
	// spaces as combinators
	var input = [],
		results = [],
		matcher = compile( selector.replace( rtrim, "$1" ) );
1641
	return matcher[ expando ] ?
		markFunction( function( seed, matches, _context, xml ) {
			var elem,
				unmatched = matcher( seed, null, xml, [] ),
				i = seed.length;
1647
			// Match elements unmatched by `matcher`
			while ( i-- ) {
				if ( ( elem = unmatched[ i ] ) ) {
					seed[ i ] = !( matches[ i ] = elem );
				}
			}
		} ) :
		function( elem, _context, xml ) {
			input[ 0 ] = elem;
			matcher( input, null, xml, results );
1658
			// Don't keep the element (issue #299)
			input[ 0 ] = null;
			return !results.pop();
		};
} ),
1664
"has": markFunction( function( selector ) {
	return function( elem ) {
		return Sizzle( selector, elem ).length > 0;
	};
} ),
1670
"contains": markFunction( function( text ) {
	text = text.replace( runescape, funescape );
	return function( elem ) {
		return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
	};
} ),
1677
// "Whether an element is represented by a :lang() selector
// is based solely on the element's language value
// being equal to the identifier C,
// or beginning with the identifier C immediately followed by "-".
// The matching of C against the element's language value is performed case-insensitively.
// The identifier C does not have to be a valid language name."
// http://www.w3.org/TR/selectors/#lang-pseudo
"lang": markFunction( function( lang ) {
1686
	// lang value must be a valid identifier
	if ( !ridentifier.test( lang || "" ) ) {
		Sizzle.error( "unsupported lang: " + lang );
	}
	lang = lang.replace( runescape, funescape ).toLowerCase();
	return function( elem ) {
		var elemLang;
		do {
			if ( ( elemLang = documentIsHTML ?
				elem.lang :
				elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
1698
				elemLang = elemLang.toLowerCase();
				return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
			}
		} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
		return false;
	};
} ),
1706
// Miscellaneous
"target": function( elem ) {
	var hash = window.location && window.location.hash;
	return hash && hash.slice( 1 ) === elem.id;
},
1712
"root": function( elem ) {
	return elem === docElem;
},
1716
"focus": function( elem ) {
	return elem === document.activeElement &&
		( !document.hasFocus || document.hasFocus() ) &&
		!!( elem.type || elem.href || ~elem.tabIndex );
},
1722
// Boolean properties
"enabled": createDisabledPseudo( false ),
"disabled": createDisabledPseudo( true ),
1726
"checked": function( elem ) {
1728
	// In CSS3, :checked should return both checked and selected elements
	// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
	var nodeName = elem.nodeName.toLowerCase();
	return ( nodeName === "input" && !!elem.checked ) ||
		( nodeName === "option" && !!elem.selected );
},
1735
"selected": function( elem ) {
1737
	// Accessing this property makes selected-by-default
	// options in Safari work properly
	if ( elem.parentNode ) {
		// eslint-disable-next-line no-unused-expressions
		elem.parentNode.selectedIndex;
	}
1744
	return elem.selected === true;
},
1747
// Contents
"empty": function( elem ) {
1750
	// http://www.w3.org/TR/selectors/#empty-pseudo
	// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
	//   but not by others (comment: 8; processing instruction: 7; etc.)
	// nodeType < 6 works because attributes (2) do not appear as children
	for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
		if ( elem.nodeType < 6 ) {
			return false;
		}
	}
	return true;
},
1762
"parent": function( elem ) {
	return !Expr.pseudos[ "empty" ]( elem );
},
1766
// Element/input types
"header": function( elem ) {
	return rheader.test( elem.nodeName );
},
1771
"input": function( elem ) {
	return rinputs.test( elem.nodeName );
},
1775
"button": function( elem ) {
	var name = elem.nodeName.toLowerCase();
	return name === "input" && elem.type === "button" || name === "button";
},
1780
"text": function( elem ) {
	var attr;
	return elem.nodeName.toLowerCase() === "input" &&
		elem.type === "text" &&
1785
		// Support: IE <10 only
		// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
		( ( attr = elem.getAttribute( "type" ) ) == null ||
			attr.toLowerCase() === "text" );
},
1791
// Position-in-collection
"first": createPositionalPseudo( function() {
	return [ 0 ];
} ),
1796
"last": createPositionalPseudo( function( _matchIndexes, length ) {
	return [ length - 1 ];
} ),
1800
"eq": createPositionalPseudo( function( _matchIndexes, length, argument ) {
	return [ argument < 0 ? argument + length : argument ];
} ),
1804
"even": createPositionalPseudo( function( matchIndexes, length ) {
	var i = 0;
	for ( ; i < length; i += 2 ) {
		matchIndexes.push( i );
	}
	return matchIndexes;
} ),
1812
"odd": createPositionalPseudo( function( matchIndexes, length ) {
	var i = 1;
	for ( ; i < length; i += 2 ) {
		matchIndexes.push( i );
	}
	return matchIndexes;
} ),
1820
"lt": createPositionalPseudo( function( matchIndexes, length, argument ) {
	var i = argument < 0 ?
		argument + length :
		argument > length ?
			length :
			argument;
	for ( ; --i >= 0; ) {
		matchIndexes.push( i );
	}
	return matchIndexes;
} ),
1832
"gt": createPositionalPseudo( function( matchIndexes, length, argument ) {
	var i = argument < 0 ? argument + length : argument;
	for ( ; ++i < length; ) {
		matchIndexes.push( i );
	}
	return matchIndexes;
} )
}
1841};
1842
1843Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ];
1844
1845// Add button/input type pseudos
1846for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
Expr.pseudos[ i ] = createInputPseudo( i );
1848}
1849for ( i in { submit: true, reset: true } ) {
Expr.pseudos[ i ] = createButtonPseudo( i );
1851}
1852
1853// Easy API for creating new setFilters
1854function setFilters() {}
1855setFilters.prototype = Expr.filters = Expr.pseudos;
1856Expr.setFilters = new setFilters();
1857
1858tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
var matched, match, tokens, type,
soFar, groups, preFilters,
cached = tokenCache[ selector + " " ];
1862
if ( cached ) {
return parseOnly ? 0 : cached.slice( 0 );
}
1866
soFar = selector;
groups = [];
preFilters = Expr.preFilter;
1870
while ( soFar ) {
1872
// Comma and first run
if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
	if ( match ) {
1876
		// Don't consume trailing commas as valid
		soFar = soFar.slice( match[ 0 ].length ) || soFar;
	}
	groups.push( ( tokens = [] ) );
}
1882
matched = false;
1884
// Combinators
if ( ( match = rcombinators.exec( soFar ) ) ) {
	matched = match.shift();
	tokens.push( {
		value: matched,
1890
		// Cast descendant combinators to space
		type: match[ 0 ].replace( rtrim, " " )
	} );
	soFar = soFar.slice( matched.length );
}
1896
// Filters
for ( type in Expr.filter ) {
	if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
		( match = preFilters[ type ]( match ) ) ) ) {
		matched = match.shift();
		tokens.push( {
			value: matched,
			type: type,
			matches: match
		} );
		soFar = soFar.slice( matched.length );
	}
}
1910
if ( !matched ) {
	break;
}
}
1915
// Return the length of the invalid excess
// if we're just parsing
// Otherwise, throw an error or return tokens
return parseOnly ?
soFar.length :
soFar ?
	Sizzle.error( selector ) :
1923
	// Cache the tokens
	tokenCache( selector, groups ).slice( 0 );
1926};
1927
1928function toSelector( tokens ) {
var i = 0,
len = tokens.length,
selector = "";
for ( ; i < len; i++ ) {
selector += tokens[ i ].value;
}
return selector;
1936}
1937
1938function addCombinator( matcher, combinator, base ) {
var dir = combinator.dir,
skip = combinator.next,
key = skip || dir,
checkNonElements = base && key === "parentNode",
doneName = done++;
1944
return combinator.first ?
1946
// Check against closest ancestor/preceding element
function( elem, context, xml ) {
	while ( ( elem = elem[ dir ] ) ) {
		if ( elem.nodeType === 1 || checkNonElements ) {
			return matcher( elem, context, xml );
		}
	}
	return false;
} :
1956
// Check against all ancestor/preceding elements
function( elem, context, xml ) {
	var oldCache, uniqueCache, outerCache,
		newCache = [ dirruns, doneName ];
1961
	// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
	if ( xml ) {
		while ( ( elem = elem[ dir ] ) ) {
			if ( elem.nodeType === 1 || checkNonElements ) {
				if ( matcher( elem, context, xml ) ) {
					return true;
				}
			}
		}
	} else {
		while ( ( elem = elem[ dir ] ) ) {
			if ( elem.nodeType === 1 || checkNonElements ) {
				outerCache = elem[ expando ] || ( elem[ expando ] = {} );
1975
				// Support: IE <9 only
				// Defend against cloned attroperties (jQuery gh-1709)
				uniqueCache = outerCache[ elem.uniqueID ] ||
					( outerCache[ elem.uniqueID ] = {} );
1980
				if ( skip && skip === elem.nodeName.toLowerCase() ) {
					elem = elem[ dir ] || elem;
				} else if ( ( oldCache = uniqueCache[ key ] ) &&
					oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
1985
					// Assign to newCache so results back-propagate to previous elements
					return ( newCache[ 2 ] = oldCache[ 2 ] );
				} else {
1989
					// Reuse newcache so results back-propagate to previous elements
					uniqueCache[ key ] = newCache;
1992
					// A match means we're done; a fail means we have to keep checking
					if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
						return true;
					}
				}
			}
		}
	}
	return false;
};
2003}
2004
2005function elementMatcher( matchers ) {
return matchers.length > 1 ?
function( elem, context, xml ) {
	var i = matchers.length;
	while ( i-- ) {
		if ( !matchers[ i ]( elem, context, xml ) ) {
			return false;
		}
	}
	return true;
} :
matchers[ 0 ];
2017}
2018
2019function multipleContexts( selector, contexts, results ) {
var i = 0,
len = contexts.length;
for ( ; i < len; i++ ) {
Sizzle( selector, contexts[ i ], results );
}
return results;
2026}
2027
2028function condense( unmatched, map, filter, context, xml ) {
var elem,
newUnmatched = [],
i = 0,
len = unmatched.length,
mapped = map != null;
2034
for ( ; i < len; i++ ) {
if ( ( elem = unmatched[ i ] ) ) {
	if ( !filter || filter( elem, context, xml ) ) {
		newUnmatched.push( elem );
		if ( mapped ) {
			map.push( i );
		}
	}
}
}
2045
return newUnmatched;
2047}
2048
2049function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
if ( postFilter && !postFilter[ expando ] ) {
postFilter = setMatcher( postFilter );
}
if ( postFinder && !postFinder[ expando ] ) {
postFinder = setMatcher( postFinder, postSelector );
}
return markFunction( function( seed, results, context, xml ) {
var temp, i, elem,
	preMap = [],
	postMap = [],
	preexisting = results.length,
2061
	// Get initial elements from seed or context
	elems = seed || multipleContexts(
		selector || "*",
		context.nodeType ? [ context ] : context,
		[]
	),
2068
	// Prefilter to get matcher input, preserving a map for seed-results synchronization
	matcherIn = preFilter && ( seed || !selector ) ?
		condense( elems, preMap, preFilter, context, xml ) :
		elems,
2073
	matcherOut = matcher ?
2075
		// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
		postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2078
			// ...intermediate processing is necessary
			[] :
2081
			// ...otherwise use results directly
			results :
		matcherIn;
2085
// Find primary matches
if ( matcher ) {
	matcher( matcherIn, matcherOut, context, xml );
}
2090
// Apply postFilter
if ( postFilter ) {
	temp = condense( matcherOut, postMap );
	postFilter( temp, [], context, xml );
2095
	// Un-match failing elements by moving them back to matcherIn
	i = temp.length;
	while ( i-- ) {
		if ( ( elem = temp[ i ] ) ) {
			matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
		}
	}
}
2104
if ( seed ) {
	if ( postFinder || preFilter ) {
		if ( postFinder ) {
2108
			// Get the final matcherOut by condensing this intermediate into postFinder contexts
			temp = [];
			i = matcherOut.length;
			while ( i-- ) {
				if ( ( elem = matcherOut[ i ] ) ) {
2114
					// Restore matcherIn since elem is not yet a final match
					temp.push( ( matcherIn[ i ] = elem ) );
				}
			}
			postFinder( null, ( matcherOut = [] ), temp, xml );
		}
2121
		// Move matched elements from seed to results to keep them synchronized
		i = matcherOut.length;
		while ( i-- ) {
			if ( ( elem = matcherOut[ i ] ) &&
				( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {
2127
				seed[ temp ] = !( results[ temp ] = elem );
			}
		}
	}
2132
// Add elements to results, through postFinder if defined
} else {
	matcherOut = condense(
		matcherOut === results ?
			matcherOut.splice( preexisting, matcherOut.length ) :
			matcherOut
	);
	if ( postFinder ) {
		postFinder( null, results, matcherOut, xml );
	} else {
		push.apply( results, matcherOut );
	}
}
} );
2147}
2148
2149function matcherFromTokens( tokens ) {
var checkContext, matcher, j,
len = tokens.length,
leadingRelative = Expr.relative[ tokens[ 0 ].type ],
implicitRelative = leadingRelative || Expr.relative[ " " ],
i = leadingRelative ? 1 : 0,
2155
// The foundational matcher ensures that elements are reachable from top-level context(s)
matchContext = addCombinator( function( elem ) {
	return elem === checkContext;
}, implicitRelative, true ),
matchAnyContext = addCombinator( function( elem ) {
	return indexOf( checkContext, elem ) > -1;
}, implicitRelative, true ),
matchers = [ function( elem, context, xml ) {
	var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
		( checkContext = context ).nodeType ?
			matchContext( elem, context, xml ) :
			matchAnyContext( elem, context, xml ) );
2168
	// Avoid hanging onto element (issue #299)
	checkContext = null;
	return ret;
} ];
2173
for ( ; i < len; i++ ) {
if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
	matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
} else {
	matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
2179
	// Return special upon seeing a positional matcher
	if ( matcher[ expando ] ) {
2182
		// Find the next relative operator (if any) for proper handling
		j = ++i;
		for ( ; j < len; j++ ) {
			if ( Expr.relative[ tokens[ j ].type ] ) {
				break;
			}
		}
		return setMatcher(
			i > 1 && elementMatcher( matchers ),
			i > 1 && toSelector(
2193
			// If the preceding token was a descendant combinator, insert an implicit any-element `*`
			tokens
				.slice( 0, i - 1 )
				.concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
			).replace( rtrim, "$1" ),
			matcher,
			i < j && matcherFromTokens( tokens.slice( i, j ) ),
			j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
			j < len && toSelector( tokens )
		);
	}
	matchers.push( matcher );
}
}
2208
return elementMatcher( matchers );
2210}
2211
2212function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
var bySet = setMatchers.length > 0,
byElement = elementMatchers.length > 0,
superMatcher = function( seed, context, xml, results, outermost ) {
	var elem, j, matcher,
		matchedCount = 0,
		i = "0",
		unmatched = seed && [],
		setMatched = [],
		contextBackup = outermostContext,
2222
		// We must always have either seed elements or outermost context
		elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ),
2225
		// Use integer dirruns iff this is the outermost matcher
		dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
		len = elems.length;
2229
	if ( outermost ) {
2231
		// Support: IE 11+, Edge 17 - 18+
		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
		// two documents; shallow comparisons work.
		// eslint-disable-next-line eqeqeq
		outermostContext = context == document || context || outermost;
	}
2238
	// Add elements passing elementMatchers directly to results
	// Support: IE<9, Safari
	// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
	for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
		if ( byElement && elem ) {
			j = 0;
2245
			// Support: IE 11+, Edge 17 - 18+
			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
			// two documents; shallow comparisons work.
			// eslint-disable-next-line eqeqeq
			if ( !context && elem.ownerDocument != document ) {
				setDocument( elem );
				xml = !documentIsHTML;
			}
			while ( ( matcher = elementMatchers[ j++ ] ) ) {
				if ( matcher( elem, context || document, xml ) ) {
					results.push( elem );
					break;
				}
			}
			if ( outermost ) {
				dirruns = dirrunsUnique;
			}
		}
2264
		// Track unmatched elements for set filters
		if ( bySet ) {
2267
			// They will have gone through all possible matchers
			if ( ( elem = !matcher && elem ) ) {
				matchedCount--;
			}
2272
			// Lengthen the array for every element, matched or not
			if ( seed ) {
				unmatched.push( elem );
			}
		}
	}
2279
	// `i` is now the count of elements visited above, and adding it to `matchedCount`
	// makes the latter nonnegative.
	matchedCount += i;
2283
	// Apply set filters to unmatched elements
	// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
	// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
	// no element matchers and no seed.
	// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
	// case, which will result in a "00" `matchedCount` that differs from `i` but is also
	// numerically zero.
	if ( bySet && i !== matchedCount ) {
		j = 0;
		while ( ( matcher = setMatchers[ j++ ] ) ) {
			matcher( unmatched, setMatched, context, xml );
		}
2296
		if ( seed ) {
2298
			// Reintegrate element matches to eliminate the need for sorting
			if ( matchedCount > 0 ) {
				while ( i-- ) {
					if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
						setMatched[ i ] = pop.call( results );
					}
				}
			}
2307
			// Discard index placeholder values to get only actual matches
			setMatched = condense( setMatched );
		}
2311
		// Add matches to results
		push.apply( results, setMatched );
2314
		// Seedless set matches succeeding multiple successful matchers stipulate sorting
		if ( outermost && !seed && setMatched.length > 0 &&
			( matchedCount + setMatchers.length ) > 1 ) {
2318
			Sizzle.uniqueSort( results );
		}
	}
2322
	// Override manipulation of globals by nested matchers
	if ( outermost ) {
		dirruns = dirrunsUnique;
		outermostContext = contextBackup;
	}
2328
	return unmatched;
};
2331
return bySet ?
markFunction( superMatcher ) :
superMatcher;
2335}
2336
2337compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
var i,
setMatchers = [],
elementMatchers = [],
cached = compilerCache[ selector + " " ];
2342
if ( !cached ) {
2344
// Generate a function of recursive functions that can be used to check each element
if ( !match ) {
	match = tokenize( selector );
}
i = match.length;
while ( i-- ) {
	cached = matcherFromTokens( match[ i ] );
	if ( cached[ expando ] ) {
		setMatchers.push( cached );
	} else {
		elementMatchers.push( cached );
	}
}
2358
// Cache the compiled function
cached = compilerCache(
	selector,
	matcherFromGroupMatchers( elementMatchers, setMatchers )
);
2364
// Save selector and tokenization
cached.selector = selector;
}
return cached;
2369};
2370
2371/**
* A low-level selection function that works with Sizzle's compiled
*  selector functions
* @param {String|Function} selector A selector or a pre-compiled
*  selector function built with Sizzle.compile
* @param {Element} context
* @param {Array} [results]
* @param {Array} [seed] A set of elements to match against
*/
2380select = Sizzle.select = function( selector, context, results, seed ) {
var i, tokens, token, type, find,
compiled = typeof selector === "function" && selector,
match = !seed && tokenize( ( selector = compiled.selector || selector ) );
2384
results = results || [];
2386
// Try to minimize operations if there is only one selector in the list and no seed
// (the latter of which guarantees us context)
if ( match.length === 1 ) {
2390
// Reduce context if the leading compound selector is an ID
tokens = match[ 0 ] = match[ 0 ].slice( 0 );
if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
	context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
2395
	context = ( Expr.find[ "ID" ]( token.matches[ 0 ]
		.replace( runescape, funescape ), context ) || [] )[ 0 ];
	if ( !context ) {
		return results;
2400
	// Precompiled matchers will still verify ancestry, so step up a level
	} else if ( compiled ) {
		context = context.parentNode;
	}
2405
	selector = selector.slice( tokens.shift().value.length );
}
2408
// Fetch a seed set for right-to-left matching
i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length;
while ( i-- ) {
	token = tokens[ i ];
2413
	// Abort if we hit a combinator
	if ( Expr.relative[ ( type = token.type ) ] ) {
		break;
	}
	if ( ( find = Expr.find[ type ] ) ) {
2419
		// Search, expanding context for leading sibling combinators
		if ( ( seed = find(
			token.matches[ 0 ].replace( runescape, funescape ),
			rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||
				context
		) ) ) {
2426
			// If seed is empty or no tokens remain, we can return early
			tokens.splice( i, 1 );
			selector = seed.length && toSelector( tokens );
			if ( !selector ) {
				push.apply( results, seed );
				return results;
			}
2434
			break;
		}
	}
}
}
2440
// Compile and execute a filtering function if one is not provided
// Provide `match` to avoid retokenization if we modified the selector above
( compiled || compile( selector, match ) )(
seed,
context,
!documentIsHTML,
results,
!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
);
return results;
2451};
2452
2453// One-time assignments
2454
2455// Sort stability
2456support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
2457
2458// Support: Chrome 14-35+
2459// Always assume duplicates if they aren't passed to the comparison function
2460support.detectDuplicates = !!hasDuplicate;
2461
2462// Initialize against the default document
2463setDocument();
2464
2465// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2466// Detached nodes confoundingly follow *each other*
2467support.sortDetached = assert( function( el ) {
2468
// Should return 1, but returns 4 (following)
return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
2471} );
2472
2473// Support: IE<8
2474// Prevent attribute/property "interpolation"
2475// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2476if ( !assert( function( el ) {
el.innerHTML = "<a href='#'></a>";
return el.firstChild.getAttribute( "href" ) === "#";
2479} ) ) {
addHandle( "type|href|height|width", function( elem, name, isXML ) {
if ( !isXML ) {
	return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
}
} );
2485}
2486
2487// Support: IE<9
2488// Use defaultValue in place of getAttribute("value")
2489if ( !support.attributes || !assert( function( el ) {
el.innerHTML = "<input/>";
el.firstChild.setAttribute( "value", "" );
return el.firstChild.getAttribute( "value" ) === "";
2493} ) ) {
addHandle( "value", function( elem, _name, isXML ) {
if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
	return elem.defaultValue;
}
} );
2499}
2500
2501// Support: IE<9
2502// Use getAttributeNode to fetch booleans when getAttribute lies
2503if ( !assert( function( el ) {
return el.getAttribute( "disabled" ) == null;
2505} ) ) {
addHandle( booleans, function( elem, name, isXML ) {
var val;
if ( !isXML ) {
	return elem[ name ] === true ? name.toLowerCase() :
		( val = elem.getAttributeNode( name ) ) && val.specified ?
			val.value :
			null;
}
} );
2515}
2516
2517// EXPOSE
2518var _sizzle = window.Sizzle;
2519
2520Sizzle.noConflict = function() {
if ( window.Sizzle === Sizzle ) {
window.Sizzle = _sizzle;
}
2524
return Sizzle;
2526};
2527
2528if ( typeof define === "function" && define.amd ) {
define( function() {
return Sizzle;
} );
2532
2533// Sizzle requires that there be a global window in Common-JS like environments
2534} else if ( typeof module !== "undefined" && module.exports ) {
module.exports = Sizzle;
2536} else {
window.Sizzle = Sizzle;
2538}
2539
2540// EXPOSE
2541
2542} )( window );
1	`/*!`
2	`* Sizzle CSS Selector Engine v2.3.9`
3	`* https://sizzlejs.com/`
4	`*`
5	`* Copyright JS Foundation and other contributors`
6	`* Released under the MIT license`
7	`* https://js.foundation/`
8	`*`
9	`* Date: 2022-12-19`
10	`*/`
11	`( function( window ) {`
12	`var i,`
13	`support,`
14	`Expr,`
15	`getText,`
16	`isXML,`
17	`tokenize,`
18	`compile,`
19	`select,`
20	`outermostContext,`
21	`sortInput,`
22	`hasDuplicate,`
23
24	`// Local document vars`
25	`setDocument,`
26	`document,`
27	`docElem,`
28	`documentIsHTML,`
29	`rbuggyQSA,`
30	`rbuggyMatches,`
31	`matches,`
32	`contains,`
33
34	`// Instance-specific data`
35	`expando = "sizzle" + 1 * new Date(),`
36	`preferredDoc = window.document,`
37	`dirruns = 0,`
38	`done = 0,`
39	`classCache = createCache(),`
40	`tokenCache = createCache(),`