https://naturalproductsconference.com/js/jquery-git.js

1/*!
2 * jQuery JavaScript Library v4.0.0-pre a70274632dc19ff4a64d7bb7657a2cc647ff38b9
3 * https://jquery.com/
4 *
5 * Copyright OpenJS Foundation and other contributors
6 * Released under the MIT license
7 * https://jquery.org/license
8 *
9 * Date: 2021-04-13T20:10Z
10 */
11( function( global, factory ) {
12
13	"use strict";
14
15	if ( typeof module === "object" && typeof module.exports === "object" ) {
16
17		// For CommonJS and CommonJS-like environments where a proper `window`
18		// is present, execute the factory and get jQuery.
19		// For environments that do not have a `window` with a `document`
20		// (such as Node.js), expose a factory as module.exports.
21		// This accentuates the need for the creation of a real `window`.
22		// e.g. var jQuery = require("jquery")(window);
23		// See ticket #14549 for more info.
24		module.exports = global.document ?
25			factory( global, true ) :
26			function( w ) {
27				if ( !w.document ) {
28					throw new Error( "jQuery requires a window with a document" );
29				}
30				return factory( w );
31			};
32	} else {
33		factory( global );
34	}
35
36// Pass this if window is not defined yet
37} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
38
39"use strict";
40
41var arr = [];
42
43var getProto = Object.getPrototypeOf;
44
45var slice = arr.slice;
46
47// Support: IE 11+
48// IE doesn't have Array#flat; provide a fallback.
49var flat = arr.flat ? function( array ) {
50	return arr.flat.call( array );
51} : function( array ) {
52	return arr.concat.apply( [], array );
53};
54
55var push = arr.push;
56
57var indexOf = arr.indexOf;
58
59// [[Class]] -> type pairs
60var class2type = {};
61
62var toString = class2type.toString;
63
64var hasOwn = class2type.hasOwnProperty;
65
66var fnToString = hasOwn.toString;
67
68var ObjectFunctionString = fnToString.call( Object );
69
70// All support tests are defined in their respective modules.
71var support = {};
72
73function isWindow( obj ) {
74	return obj != null && obj === obj.window;
75}
76
77var document = window.document;
78
79var preservedScriptAttributes = {
80	type: true,
81	src: true,
82	nonce: true,
83	noModule: true
84};
85
86function DOMEval( code, node, doc ) {
87	doc = doc || document;
88
89	var i,
90		script = doc.createElement( "script" );
91
92	script.text = code;
93	if ( node ) {
94		for ( i in preservedScriptAttributes ) {
95			if ( node[ i ] ) {
96				script[ i ] = node[ i ];
97			}
98		}
99	}
100	doc.head.appendChild( script ).parentNode.removeChild( script );
101}
102
103function toType( obj ) {
104	if ( obj == null ) {
105		return obj + "";
106	}
107
108	return typeof obj === "object" ?
109		class2type[ toString.call( obj ) ] || "object" :
110		typeof obj;
111}
112
113var version = "4.0.0-pre a70274632dc19ff4a64d7bb7657a2cc647ff38b9",
114
115	rhtmlSuffix = /HTML$/i,
116
117	// Define a local copy of jQuery
118	jQuery = function( selector, context ) {
119
120		// The jQuery object is actually just the init constructor 'enhanced'
121		// Need init if jQuery is called (just allow error to be thrown if not included)
122		return new jQuery.fn.init( selector, context );
123	};
124
125jQuery.fn = jQuery.prototype = {
126
127	// The current version of jQuery being used
128	jquery: version,
129
130	constructor: jQuery,
131
132	// The default length of a jQuery object is 0
133	length: 0,
134
135	toArray: function() {
136		return slice.call( this );
137	},
138
139	// Get the Nth element in the matched element set OR
140	// Get the whole matched element set as a clean array
141	get: function( num ) {
142
143		// Return all the elements in a clean array
144		if ( num == null ) {
145			return slice.call( this );
146		}
147
148		// Return just the one element from the set
149		return num < 0 ? this[ num + this.length ] : this[ num ];
150	},
151
152	// Take an array of elements and push it onto the stack
153	// (returning the new matched element set)
154	pushStack: function( elems ) {
155
156		// Build a new jQuery matched element set
157		var ret = jQuery.merge( this.constructor(), elems );
158
159		// Add the old object onto the stack (as a reference)
160		ret.prevObject = this;
161
162		// Return the newly-formed element set
163		return ret;
164	},
165
166	// Execute a callback for every element in the matched set.
167	each: function( callback ) {
168		return jQuery.each( this, callback );
169	},
170
171	map: function( callback ) {
172		return this.pushStack( jQuery.map( this, function( elem, i ) {
173			return callback.call( elem, i, elem );
174		} ) );
175	},
176
177	slice: function() {
178		return this.pushStack( slice.apply( this, arguments ) );
179	},
180
181	first: function() {
182		return this.eq( 0 );
183	},
184
185	last: function() {
186		return this.eq( -1 );
187	},
188
189	even: function() {
190		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
191			return ( i + 1 ) % 2;
192		} ) );
193	},
194
195	odd: function() {
196		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
197			return i % 2;
198		} ) );
199	},
200
201	eq: function( i ) {
202		var len = this.length,
203			j = +i + ( i < 0 ? len : 0 );
204		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
205	},
206
207	end: function() {
208		return this.prevObject || this.constructor();
209	}
210};
211
212jQuery.extend = jQuery.fn.extend = function() {
213	var options, name, src, copy, copyIsArray, clone,
214		target = arguments[ 0 ] || {},
215		i = 1,
216		length = arguments.length,
217		deep = false;

218
219	// Handle a deep copy situation
220	if ( typeof target === "boolean" ) {
221		deep = target;
222
223		// Skip the boolean and the target
224		target = arguments[ i ] || {};
225		i++;
226	}
227
228	// Handle case when target is a string or something (possible in deep copy)
229	if ( typeof target !== "object" && typeof target !== "function" ) {
230		target = {};
231	}
232
233	// Extend jQuery itself if only one argument is passed
234	if ( i === length ) {
235		target = this;
236		i--;
237	}
238
239	for ( ; i < length; i++ ) {
240
241		// Only deal with non-null/undefined values
242		if ( ( options = arguments[ i ] ) != null ) {
243
244			// Extend the base object
245			for ( name in options ) {
246				copy = options[ name ];
247
248				// Prevent Object.prototype pollution
249				// Prevent never-ending loop
250				if ( name === "__proto__" || target === copy ) {
251					continue;
252				}
253
254				// Recurse if we're merging plain objects or arrays
255				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
256					( copyIsArray = Array.isArray( copy ) ) ) ) {
257					src = target[ name ];
258
259					// Ensure proper type for the source value
260					if ( copyIsArray && !Array.isArray( src ) ) {
261						clone = [];
262					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
263						clone = {};
264					} else {
265						clone = src;
266					}
267					copyIsArray = false;
268
269					// Never move original objects, clone them
270					target[ name ] = jQuery.extend( deep, clone, copy );
271
272				// Don't bring in undefined values
273				} else if ( copy !== undefined ) {
274					target[ name ] = copy;
275				}
276			}
277		}
278	}
279
280	// Return the modified object
281	return target;
282};
283
284jQuery.extend( {
285
286	// Unique for each copy of jQuery on the page
287	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
288
289	// Assume jQuery is ready without the ready module
290	isReady: true,
291
292	error: function( msg ) {
293		throw new Error( msg );
294	},
295
296	noop: function() {},
297
298	isPlainObject: function( obj ) {
299		var proto, Ctor;
300
301		// Detect obvious negatives
302		// Use toString instead of jQuery.type to catch host objects
303		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
304			return false;
305		}
306
307		proto = getProto( obj );
308
309		// Objects with no prototype (e.g., `Object.create( null )`) are plain
310		if ( !proto ) {
311			return true;
312		}
313
314		// Objects with prototype are plain iff they were constructed by a global Object function
315		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
316		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
317	},
318
319	isEmptyObject: function( obj ) {
320		var name;
321
322		for ( name in obj ) {
323			return false;
324		}
325		return true;
326	},
327
328	// Evaluates a script in a provided context; falls back to the global one
329	// if not specified.
330	globalEval: function( code, options, doc ) {
331		DOMEval( code, { nonce: options && options.nonce }, doc );
332	},
333
334	each: function( obj, callback ) {
335		var length, i = 0;
336
337		if ( isArrayLike( obj ) ) {
338			length = obj.length;
339			for ( ; i < length; i++ ) {
340				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
341					break;
342				}
343			}
344		} else {
345			for ( i in obj ) {
346				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
347					break;
348				}
349			}
350		}
351
352		return obj;
353	},
354
355
356	// Retrieve the text value of an array of DOM nodes
357	text: function( elem ) {
358		var node,
359			ret = "",
360			i = 0,
361			nodeType = elem.nodeType;
362
363		if ( !nodeType ) {
364
365			// If no nodeType, this is expected to be an array
366			while ( ( node = elem[ i++ ] ) ) {
367
368				// Do not traverse comment nodes
369				ret += jQuery.text( node );
370			}
371		} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
372			return elem.textContent;
373		} else if ( nodeType === 3 || nodeType === 4 ) {
374			return elem.nodeValue;
375		}
376
377		// Do not include comment or processing instruction nodes
378
379		return ret;
380	},
381
382
383	// results is for internal usage only
384	makeArray: function( arr, results ) {
385		var ret = results || [];
386
387		if ( arr != null ) {
388			if ( isArrayLike( Object( arr ) ) ) {
389				jQuery.merge( ret,
390					typeof arr === "string" ?
391						[ arr ] : arr
392				);
393			} else {
394				push.call( ret, arr );
395			}
396		}
397
398		return ret;
399	},
400
401	inArray: function( elem, arr, i ) {
402		return arr == null ? -1 : indexOf.call( arr, elem, i );
403	},
404
405	isXMLDoc: function( elem ) {
406		var namespace = elem && elem.namespaceURI,
407			docElem = elem && ( elem.ownerDocument || elem ).documentElement;
408
409		// Assume HTML when documentElement doesn't yet exist, such as inside
410		// document fragments.
411		return !rhtmlSuffix.test( namespace || docElem && docElem.nodeName || "HTML" );
412	},
413
414	merge: function( first, second ) {
415		var len = +second.length,
416			j = 0,
417			i = first.length;
418
419		for ( ; j < len; j++ ) {
420			first[ i++ ] = second[ j ];
421		}
422
423		first.length = i;
424
425		return first;
426	},
427
428	grep: function( elems, callback, invert ) {
429		var callbackInverse,
430			matches = [],
431			i = 0,
432			length = elems.length,
433			callbackExpect = !invert;
434
435		// Go through the array, only saving the items
436		// that pass the validator function
437		for ( ; i < length; i++ ) {
438			callbackInverse = !callback( elems[ i ], i );
439			if ( callbackInverse !== callbackExpect ) {
440				matches.push( elems[ i ] );
441			}
442		}
443
444		return matches;
445	},
446
447	// arg is for internal usage only
448	map: function( elems, callback, arg ) {
449		var length, value,
450			i = 0,
451			ret = [];
452
453		// Go through the array, translating each of the items to their new values
454		if ( isArrayLike( elems ) ) {
455			length = elems.length;
456			for ( ; i < length; i++ ) {
457				value = callback( elems[ i ], i, arg );
458
459				if ( value != null ) {

460					ret.push( value );
461				}
462			}
463
464		// Go through every key on the object,
465		} else {
466			for ( i in elems ) {
467				value = callback( elems[ i ], i, arg );
468
469				if ( value != null ) {
470					ret.push( value );
471				}
472			}
473		}
474
475		// Flatten any nested arrays
476		return flat( ret );
477	},
478
479	// A global GUID counter for objects
480	guid: 1,
481
482	// jQuery.support is not used in Core but other projects attach their
483	// properties to it so it needs to exist.
484	support: support
485} );
486
487if ( typeof Symbol === "function" ) {
488	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
489}
490
491// Populate the class2type map
492jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
493	function( _i, name ) {
494		class2type[ "[object " + name + "]" ] = name.toLowerCase();
495	} );
496
497function isArrayLike( obj ) {
498
499	var length = !!obj && obj.length,
500		type = toType( obj );
501
502	if ( typeof obj === "function" || isWindow( obj ) ) {
503		return false;
504	}
505
506	return type === "array" || length === 0 ||
507		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
508}
509
510function nodeName( elem, name ) {
511
512	return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
513
514}
515
516var documentElement = document.documentElement;
517
518var pop = arr.pop;
519
520// https://www.w3.org/TR/css3-selectors/#whitespace
521var whitespace = "[\\x20\\t\\r\\n\\f]";
522
523var isIE = document.documentMode;
524
525var rbuggyQSA = isIE && new RegExp(
526
527	// Support: IE 9 - 11+
528	// IE's :disabled selector does not pick up the children of disabled fieldsets
529	":enabled|:disabled|" +
530
531	// Support: IE 11+
532	// IE 11 doesn't find elements on a `[name='']` query in some cases.
533	// Adding a temporary attribute to the document before the selection works
534	// around the issue.
535	"\\[" + whitespace + "*name" + whitespace + "*=" +
536		whitespace + "*(?:''|\"\")"
537
538);
539
540// Note: an element does not contain itself
541jQuery.contains = function( a, b ) {
542	var adown = a.nodeType === 9 ? a.documentElement : a,
543		bup = b && b.parentNode;
544
545	return a === bup || !!( bup && bup.nodeType === 1 && (
546
547		// Support: IE 9 - 11+
548		// IE doesn't have `contains` on SVG.
549		adown.contains ?
550			adown.contains( bup ) :
551			a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
552	) );
553};
554
555// CSS string/identifier serialization
556// https://drafts.csswg.org/cssom/#common-serializing-idioms
557var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g;
558
559function fcssescape( ch, asCodePoint ) {
560	if ( asCodePoint ) {
561
562		// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
563		if ( ch === "\0" ) {
564			return "\uFFFD";
565		}
566
567		// Control characters and (dependent upon position) numbers get escaped as code points
568		return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
569	}
570
571	// Other potentially-special ASCII characters get backslash-escaped
572	return "\\" + ch;
573}
574
575jQuery.escapeSelector = function( sel ) {
576	return ( sel + "" ).replace( rcssescape, fcssescape );
577};
578
579var sort = arr.sort;
580
581var hasDuplicate;
582
583// Document order sorting
584function sortOrder( a, b ) {
585
586	// Flag for duplicate removal
587	if ( a === b ) {
588		hasDuplicate = true;
589		return 0;
590	}
591
592	// Sort on method existence if only one input has compareDocumentPosition
593	var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
594	if ( compare ) {
595		return compare;
596	}
597
598	// Calculate position if both inputs belong to the same document
599	// Support: IE 11+
600	// IE sometimes throws a "Permission denied" error when strict-comparing
601	// two documents; shallow comparisons work.
602	// eslint-disable-next-line eqeqeq
603	compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
604		a.compareDocumentPosition( b ) :
605
606		// Otherwise we know they are disconnected
607		1;
608
609	// Disconnected nodes
610	if ( compare & 1 ) {
611
612		// Choose the first element that is related to the document

755	// Easily-parseable/retrievable ID or TAG or CLASS selectors
756	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
757
758	rsibling = /[+~]/,
759
760	// CSS escapes
761	// https://www.w3.org/TR/CSS21/syndata.html#escaped-characters
762	runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace +
763		"?|\\\\([^\\r\\n\\f])", "g" ),
764	funescape = function( escape, nonHex ) {
765		var high = "0x" + escape.slice( 1 ) - 0x10000;
766
767		if ( nonHex ) {
768
769			// Strip the backslash prefix from a non-hex escape sequence
770			return nonHex;
771		}
772
773		// Replace a hexadecimal escape sequence with the encoded Unicode code point
774		// Support: IE <=11+
775		// For values outside the Basic Multilingual Plane (BMP), manually construct a
776		// surrogate pair
777		return high < 0 ?
778			String.fromCharCode( high + 0x10000 ) :
779			String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
780	},
781
782	// Used for iframes; see `setDocument`.
783	// Support: IE 9 - 11+
784	// Removing the function wrapper causes a "Permission Denied"
785	// error in IE.
786	unloadHandler = function() {
787		setDocument();
788	},
789
790	inDisabledFieldset = addCombinator(
791		function( elem ) {
792			return elem.disabled === true && nodeName( elem, "fieldset" );
793		},
794		{ dir: "parentNode", next: "legend" }
795	);
796
797function selectorError( msg ) {
798	throw new Error( "Syntax error, unrecognized expression: " + msg );
799}
800
801function find( selector, context, results, seed ) {
802	var m, i, elem, nid, match, groups, newSelector,
803		newContext = context && context.ownerDocument,
804
805		// nodeType defaults to 9, since context defaults to document
806		nodeType = context ? context.nodeType : 9;
807
808	results = results || [];
809
810	// Return early from calls with invalid selector or context
811	if ( typeof selector !== "string" || !selector ||
812		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
813
814		return results;
815	}
816
817	// Try to shortcut find operations (as opposed to filters) in HTML documents
818	if ( !seed ) {
819		setDocument( context );
820		context = context || document;
821
822		if ( documentIsHTML ) {
823
824			// If the selector is sufficiently simple, try using a "get*By*" DOM method
825			// (excepting DocumentFragment context, where the methods don't exist)
826			if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
827
828				// ID selector
829				if ( ( m = match[ 1 ] ) ) {
830
831					// Document context
832					if ( nodeType === 9 ) {
833						if ( ( elem = context.getElementById( m ) ) ) {
834							push.call( results, elem );
835						}
836						return results;
837
838					// Element context
839					} else {
840						if ( newContext && ( elem = newContext.getElementById( m ) ) &&
841							jQuery.contains( context, elem ) ) {
842
843							push.call( results, elem );
844							return results;
845						}
846					}
847
848				// Type selector
849				} else if ( match[ 2 ] ) {
850					push.apply( results, context.getElementsByTagName( selector ) );
851					return results;
852
853				// Class selector
854				} else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) {
855					push.apply( results, context.getElementsByClassName( m ) );
856					return results;
857				}
858			}
859
860			// Take advantage of querySelectorAll
861			if ( !nonnativeSelectorCache[ selector + " " ] &&
862				( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) {
863
864				newSelector = selector;
865				newContext = context;
866
867				// qSA considers elements outside a scoping root when evaluating child or
868				// descendant combinators, which is not what we want.
869				// In such cases, we work around the behavior by prefixing every selector in the
870				// list with an ID selector referencing the scope context.
871				// The technique has to be used as well when a leading combinator is used
872				// as such selectors are not recognized by querySelectorAll.
873				// Thanks to Andrew Dupont for this technique.
874				if ( nodeType === 1 &&
875					( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
876
877					// Expand context for sibling selectors
878					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
879						context;
880
881					// Outside of IE, if we're not changing the context we can
882					// use :scope instead of an ID.
883					if ( newContext !== context || isIE ) {
884
885						// Capture the context ID, setting it first if necessary
886						if ( ( nid = context.getAttribute( "id" ) ) ) {
887							nid = jQuery.escapeSelector( nid );
888						} else {
889							context.setAttribute( "id", ( nid = expando ) );
890						}
891					}
892
893					// Prefix every selector in the list
894					groups = tokenize( selector );
895					i = groups.length;
896					while ( i-- ) {
897						groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
898							toSelector( groups[ i ] );
899					}
900					newSelector = groups.join( "," );
901				}
902
903				try {
904					push.apply( results,
905						newContext.querySelectorAll( newSelector )
906					);
907					return results;
908				} catch ( qsaError ) {
909					nonnativeSelectorCache( selector, true );
910				} finally {
911					if ( nid === expando ) {
912						context.removeAttribute( "id" );
913					}
914				}
915			}
916		}
917	}
918
919	// All others
920	return select( selector.replace( rtrim, "$1" ), context, results, seed );
921}
922
923/**
924 * Create key-value caches of limited size
925 * @returns {function(string, object)} Returns the Object data after storing it on itself with
926 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
927 *	deleting the oldest entry
928 */
929function createCache() {
930	var keys = [];
931
932	function cache( key, value ) {
933
934		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
935		if ( keys.push( key + " " ) > Expr.cacheLength ) {
936
937			// Only keep the most recent entries
938			delete cache[ keys.shift() ];
939		}
940		return ( cache[ key + " " ] = value );
941	}
942	return cache;
943}
944
945/**
946 * Mark a function for special use by jQuery selector module
947 * @param {Function} fn The function to mark
948 */
949function markFunction( fn ) {
950	fn[ expando ] = true;
951	return fn;
952}
953
954/**
955 * Returns a function to use in pseudos for input types
956 * @param {String} type
957 */
958function createInputPseudo( type ) {
959	return function( elem ) {
960		return nodeName( elem, "input" ) && elem.type === type;
961	};
962}
963
964/**
965 * Returns a function to use in pseudos for buttons
966 * @param {String} type
967 */
968function createButtonPseudo( type ) {
969	return function( elem ) {
970		return ( nodeName( elem, "input" ) || nodeName( elem, "button" ) ) &&
971			elem.type === type;
972	};
973}
974
975/**
976 * Returns a function to use in pseudos for :enabled/:disabled
977 * @param {Boolean} disabled true for :disabled; false for :enabled
978 */
979function createDisabledPseudo( disabled ) {
980
981	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
982	return function( elem ) {
983
984		// Only certain elements can match :enabled or :disabled
985		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
986		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
987		if ( "form" in elem ) {
988
989			// Check for inherited disabledness on relevant non-disabled elements:
990			// * listed form-associated elements in a disabled fieldset
991			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
992			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
993			// * option elements in a disabled optgroup
994			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
995			// All such elements have a "form" property.
996			if ( elem.parentNode && elem.disabled === false ) {
997
998				// Option elements defer to a parent optgroup if present
999				if ( "label" in elem ) {
1000					if ( "label" in elem.parentNode ) {
1001						return elem.parentNode.disabled === disabled;
1002					} else {
1003						return elem.disabled === disabled;
1004					}
1005				}
1006

1007				// Support: IE 6 - 11+
1008				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
1009				return elem.isDisabled === disabled ||
1010
1011					// Where there is no isDisabled, check manually
1012					elem.isDisabled !== !disabled &&
1013						inDisabledFieldset( elem ) === disabled;
1014			}
1015
1016			return elem.disabled === disabled;
1017
1018		// Try to winnow out elements that can't be disabled before trusting the disabled property.
1019		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1020		// even exist on them, let alone have a boolean value.
1021		} else if ( "label" in elem ) {
1022			return elem.disabled === disabled;
1023		}
1024
1025		// Remaining elements are neither :enabled nor :disabled
1026		return false;
1027	};
1028}
1029
1030/**
1031 * Returns a function to use in pseudos for positionals
1032 * @param {Function} fn
1033 */
1034function createPositionalPseudo( fn ) {
1035	return markFunction( function( argument ) {
1036		argument = +argument;
1037		return markFunction( function( seed, matches ) {
1038			var j,
1039				matchIndexes = fn( [], seed.length, argument ),
1040				i = matchIndexes.length;
1041
1042			// Match elements found at the specified indexes
1043			while ( i-- ) {
1044				if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
1045					seed[ j ] = !( matches[ j ] = seed[ j ] );
1046				}
1047			}
1048		} );
1049	} );
1050}
1051
1052/**
1053 * Checks a node for validity as a jQuery selector context
1054 * @param {Element|Object=} context
1055 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1056 */
1057function testContext( context ) {
1058	return context && typeof context.getElementsByTagName !== "undefined" && context;
1059}
1060
1061/**
1062 * Sets document-related variables once based on the current document
1063 * @param {Element|Object} [node] An element or document object to use to set the document
1064 */
1065function setDocument( node ) {
1066	var subWindow,
1067		doc = node ? node.ownerDocument || node : preferredDoc;
1068
1069	// Return early if doc is invalid or already selected
1070	// Support: IE 11+
1071	// IE sometimes throws a "Permission denied" error when strict-comparing
1072	// two documents; shallow comparisons work.
1073	// eslint-disable-next-line eqeqeq
1074	if ( doc == document || doc.nodeType !== 9 ) {
1075		return;
1076	}
1077
1078	// Update global variables
1079	document = doc;
1080	documentElement = document.documentElement;
1081	documentIsHTML = !jQuery.isXMLDoc( document );
1082
1083	// Support: IE 9 - 11+
1084	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1085	// Support: IE 11+
1086	// IE sometimes throws a "Permission denied" error when strict-comparing
1087	// two documents; shallow comparisons work.
1088	// eslint-disable-next-line eqeqeq
1089	if ( isIE && preferredDoc != document &&
1090		( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
1091		subWindow.addEventListener( "unload", unloadHandler );
1092	}
1093}
1094
1095find.matches = function( expr, elements ) {
1096	return find( expr, null, null, elements );
1097};
1098
1099find.matchesSelector = function( elem, expr ) {
1100	setDocument( elem );
1101
1102	if ( documentIsHTML &&
1103		!nonnativeSelectorCache[ expr + " " ] &&
1104		( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {
1105
1106		try {
1107			return matches.call( elem, expr );
1108		} catch ( e ) {
1109			nonnativeSelectorCache( expr, true );
1110		}
1111	}
1112
1113	return find( expr, document, null, [ elem ] ).length > 0;
1114};
1115
1116Expr = jQuery.expr = {
1117
1118	// Can be adjusted by the user
1119	cacheLength: 50,
1120
1121	createPseudo: markFunction,
1122
1123	match: matchExpr,
1124
1125	find: {
1126		ID: function( id, context ) {
1127			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1128				var elem = context.getElementById( id );
1129				return elem ? [ elem ] : [];
1130			}
1131		},
1132
1133		TAG: function( tag, context ) {
1134			if ( typeof context.getElementsByTagName !== "undefined" ) {
1135				return context.getElementsByTagName( tag );
1136
1137				// DocumentFragment nodes don't have gEBTN
1138			} else {
1139				return context.querySelectorAll( tag );
1140			}
1141		},
1142
1143		CLASS: function( className, context ) {
1144			if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1145				return context.getElementsByClassName( className );
1146			}
1147		}
1148	},
1149
1150	relative: {
1151		">": { dir: "parentNode", first: true },
1152		" ": { dir: "parentNode" },
1153		"+": { dir: "previousSibling", first: true },
1154		"~": { dir: "previousSibling" }
1155	},
1156
1157	preFilter: {
1158		ATTR: function( match ) {
1159			match[ 1 ] = match[ 1 ].replace( runescape, funescape );
1160
1161			// Move the given value to match[3] whether quoted or unquoted
1162			match[ 3 ] = ( match[ 3 ] || match[ 4 ] || match[ 5 ] || "" )
1163				.replace( runescape, funescape );
1164
1165			if ( match[ 2 ] === "~=" ) {
1166				match[ 3 ] = " " + match[ 3 ] + " ";
1167			}
1168
1169			return match.slice( 0, 4 );
1170		},
1171
1172		CHILD: function( match ) {
1173
1174			/* matches from matchExpr["CHILD"]
1175				1 type (only|nth|...)
1176				2 what (child|of-type)

1177				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1178				4 xn-component of xn+y argument ([+-]?\d*n|)
1179				5 sign of xn-component
1180				6 x of xn-component
1181				7 sign of y-component
1182				8 y of y-component
1183			*/
1184			match[ 1 ] = match[ 1 ].toLowerCase();
1185
1186			if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
1187
1188				// nth-* requires argument
1189				if ( !match[ 3 ] ) {
1190					selectorError( match[ 0 ] );
1191				}
1192
1193				// numeric x and y parameters for Expr.filter.CHILD
1194				// remember that false/true cast respectively to 0/1
1195				match[ 4 ] = +( match[ 4 ] ?
1196					match[ 5 ] + ( match[ 6 ] || 1 ) :
1197					2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" )
1198				);
1199				match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
1200
1201			// other types prohibit arguments
1202			} else if ( match[ 3 ] ) {
1203				selectorError( match[ 0 ] );
1204			}
1205
1206			return match;
1207		},
1208
1209		PSEUDO: function( match ) {
1210			var excess,
1211				unquoted = !match[ 6 ] && match[ 2 ];
1212
1213			if ( matchExpr.CHILD.test( match[ 0 ] ) ) {
1214				return null;
1215			}
1216
1217			// Accept quoted arguments as-is
1218			if ( match[ 3 ] ) {
1219				match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
1220
1221			// Strip excess characters from unquoted arguments
1222			} else if ( unquoted && rpseudo.test( unquoted ) &&
1223
1224				// Get excess from tokenize (recursively)
1225				( excess = tokenize( unquoted, true ) ) &&
1226
1227				// advance to the next closing parenthesis
1228				( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
1229
1230				// excess is a negative index
1231				match[ 0 ] = match[ 0 ].slice( 0, excess );
1232				match[ 2 ] = unquoted.slice( 0, excess );
1233			}
1234
1235			// Return only captures needed by the pseudo filter method (type and argument)
1236			return match.slice( 0, 3 );
1237		}
1238	},
1239
1240	filter: {
1241		ID: function( id ) {
1242			var attrId = id.replace( runescape, funescape );
1243			return function( elem ) {
1244				return elem.getAttribute( "id" ) === attrId;
1245			};
1246		},
1247
1248		TAG: function( nodeNameSelector ) {
1249			var expectedNodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1250			return nodeNameSelector === "*" ?
1251
1252				function() {
1253					return true;
1254				} :
1255
1256				function( elem ) {
1257					return nodeName( elem, expectedNodeName );
1258				};
1259		},
1260
1261		CLASS: function( className ) {
1262			var pattern = classCache[ className + " " ];
1263
1264			return pattern ||
1265				( pattern = new RegExp( "(^|" + whitespace + ")" + className +
1266					"(" + whitespace + "|$)" ) ) &&
1267				classCache( className, function( elem ) {
1268					return pattern.test(
1269						typeof elem.className === "string" && elem.className ||
1270							typeof elem.getAttribute !== "undefined" &&
1271								elem.getAttribute( "class" ) ||
1272							""
1273					);
1274				} );
1275		},
1276
1277		ATTR: function( name, operator, check ) {
1278			return function( elem ) {
1279				var result = jQuery.attr( elem, name );
1280
1281				if ( result == null ) {
1282					return operator === "!=";
1283				}
1284				if ( !operator ) {
1285					return true;
1286				}
1287
1288				result += "";
1289
1290				if ( operator === "=" ) {
1291					return result === check;
1292				}
1293				if ( operator === "!=" ) {
1294					return result !== check;
1295				}
1296				if ( operator === "^=" ) {
1297					return check && result.indexOf( check ) === 0;
1298				}
1299				if ( operator === "*=" ) {
1300					return check && result.indexOf( check ) > -1;
1301				}
1302				if ( operator === "$=" ) {
1303					return check && result.slice( -check.length ) === check;
1304				}
1305				if ( operator === "~=" ) {
1306					return ( " " + result.replace( rwhitespace, " " ) + " " )
1307						.indexOf( check ) > -1;
1308				}
1309				if ( operator === "|=" ) {
1310					return result === check || result.slice( 0, check.length + 1 ) === check + "-";
1311				}
1312
1313				return false;
1314			};
1315		},
1316
1317		CHILD: function( type, what, _argument, first, last ) {
1318			var simple = type.slice( 0, 3 ) !== "nth",
1319				forward = type.slice( -4 ) !== "last",
1320				ofType = what === "of-type";
1321
1322			return first === 1 && last === 0 ?
1323
1324				// Shortcut for :nth-*(n)
1325				function( elem ) {
1326					return !!elem.parentNode;
1327				} :
1328
1329				function( elem, _context, xml ) {
1330					var cache, outerCache, node, nodeIndex, start,
1331						dir = simple !== forward ? "nextSibling" : "previousSibling",
1332						parent = elem.parentNode,
1333						name = ofType && elem.nodeName.toLowerCase(),
1334						useCache = !xml && !ofType,
1335						diff = false;

1336
1337					if ( parent ) {
1338
1339						// :(first|last|only)-(child|of-type)
1340						if ( simple ) {
1341							while ( dir ) {
1342								node = elem;
1343								while ( ( node = node[ dir ] ) ) {
1344									if ( ofType ?
1345										nodeName( node, name ) :
1346										node.nodeType === 1 ) {
1347
1348										return false;
1349									}
1350								}
1351
1352								// Reverse direction for :only-* (if we haven't yet done so)
1353								start = dir = type === "only" && !start && "nextSibling";
1354							}
1355							return true;
1356						}
1357
1358						start = [ forward ? parent.firstChild : parent.lastChild ];
1359
1360						// non-xml :nth-child(...) stores cache data on `parent`
1361						if ( forward && useCache ) {
1362
1363							// Seek `elem` from a previously-cached index
1364							outerCache = parent[ expando ] || ( parent[ expando ] = {} );
1365							cache = outerCache[ type ] || [];
1366							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1367							diff = nodeIndex && cache[ 2 ];
1368							node = nodeIndex && parent.childNodes[ nodeIndex ];
1369
1370							while ( ( node = ++nodeIndex && node && node[ dir ] ||
1371
1372								// Fallback to seeking `elem` from the start
1373								( diff = nodeIndex = 0 ) || start.pop() ) ) {
1374
1375								// When found, cache indexes on `parent` and break
1376								if ( node.nodeType === 1 && ++diff && node === elem ) {
1377									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
1378									break;
1379								}
1380							}
1381
1382						} else {
1383
1384							// Use previously-cached element index if available
1385							if ( useCache ) {
1386								outerCache = elem[ expando ] || ( elem[ expando ] = {} );
1387								cache = outerCache[ type ] || [];
1388								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1389								diff = nodeIndex;
1390							}
1391
1392							// xml :nth-child(...)
1393							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
1394							if ( diff === false ) {
1395
1396								// Use the same loop as above to seek `elem` from the start
1397								while ( ( node = ++nodeIndex && node && node[ dir ] ||
1398									( diff = nodeIndex = 0 ) || start.pop() ) ) {
1399
1400									if ( ( ofType ?
1401										nodeName( node, name ) :
1402										node.nodeType === 1 ) &&
1403										++diff ) {
1404
1405										// Cache the index of each encountered element
1406										if ( useCache ) {
1407											outerCache = node[ expando ] ||
1408												( node[ expando ] = {} );
1409											outerCache[ type ] = [ dirruns, diff ];
1410										}
1411
1412										if ( node === elem ) {
1413											break;
1414										}
1415									}
1416								}
1417							}
1418						}
1419
1420						// Incorporate the offset, then check against cycle size
1421						diff -= last;
1422						return diff === first || ( diff % first === 0 && diff / first >= 0 );
1423					}
1424				};
1425		},
1426
1427		PSEUDO: function( pseudo, argument ) {
1428
1429			// pseudo-class names are case-insensitive
1430			// https://www.w3.org/TR/selectors/#pseudo-classes
1431			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1432			// Remember that setFilters inherits from pseudos
1433			var args,
1434				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1435					selectorError( "unsupported pseudo: " + pseudo );
1436
1437			// The user may use createPseudo to indicate that
1438			// arguments are needed to create the filter function
1439			// just as jQuery does
1440			if ( fn[ expando ] ) {
1441				return fn( argument );
1442			}
1443
1444			// But maintain support for old signatures
1445			if ( fn.length > 1 ) {
1446				args = [ pseudo, pseudo, "", argument ];
1447				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
1448					markFunction( function( seed, matches ) {
1449						var idx,
1450							matched = fn( seed, argument ),
1451							i = matched.length;
1452						while ( i-- ) {
1453							idx = indexOf.call( seed, matched[ i ] );
1454							seed[ idx ] = !( matches[ idx ] = matched[ i ] );
1455						}
1456					} ) :
1457					function( elem ) {
1458						return fn( elem, 0, args );
1459					};
1460			}
1461
1462			return fn;
1463		}
1464	},
1465
1466	pseudos: {
1467
1468		// Potentially complex pseudos
1469		not: markFunction( function( selector ) {
1470
1471			// Trim the selector passed to compile
1472			// to avoid treating leading and trailing
1473			// spaces as combinators
1474			var input = [],
1475				results = [],
1476				matcher = compile( selector.replace( rtrim, "$1" ) );
1477
1478			return matcher[ expando ] ?
1479				markFunction( function( seed, matches, _context, xml ) {
1480					var elem,
1481						unmatched = matcher( seed, null, xml, [] ),
1482						i = seed.length;
1483
1484					// Match elements unmatched by `matcher`
1485					while ( i-- ) {
1486						if ( ( elem = unmatched[ i ] ) ) {
1487							seed[ i ] = !( matches[ i ] = elem );
1488						}
1489					}
1490				} ) :
1491				function( elem, _context, xml ) {
1492					input[ 0 ] = elem;
1493					matcher( input, null, xml, results );
1494
1495					// Don't keep the element (issue #299)
1496					input[ 0 ] = null;
1497					return !results.pop();
1498				};
1499		} ),
1500
1501		has: markFunction( function( selector ) {
1502			return function( elem ) {
1503				return find( selector, elem ).length > 0;
1504			};
1505		} ),
1506
1507		contains: markFunction( function( text ) {
1508			text = text.replace( runescape, funescape );
1509			return function( elem ) {
1510				return ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1;
1511			};
1512		} ),
1513
1514		// "Whether an element is represented by a :lang() selector
1515		// is based solely on the element's language value
1516		// being equal to the identifier C,
1517		// or beginning with the identifier C immediately followed by "-".
1518		// The matching of C against the element's language value is performed case-insensitively.
1519		// The identifier C does not have to be a valid language name."
1520		// https://www.w3.org/TR/selectors/#lang-pseudo
1521		lang: markFunction( function( lang ) {
1522
1523			// lang value must be a valid identifier
1524			if ( !ridentifier.test( lang || "" ) ) {
1525				selectorError( "unsupported lang: " + lang );
1526			}
1527			lang = lang.replace( runescape, funescape ).toLowerCase();
1528			return function( elem ) {
1529				var elemLang;
1530				do {
1531					if ( ( elemLang = documentIsHTML ?
1532						elem.lang :
1533						elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
1534
1535						elemLang = elemLang.toLowerCase();
1536						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
1537					}
1538				} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
1539				return false;
1540			};
1541		} ),
1542
1543		// Miscellaneous
1544		target: function( elem ) {
1545			var hash = window.location && window.location.hash;
1546			return hash && hash.slice( 1 ) === elem.id;
1547		},
1548
1549		root: function( elem ) {
1550			return elem === documentElement;
1551		},
1552
1553		focus: function( elem ) {
1554			return elem === document.activeElement &&
1555				document.hasFocus() &&
1556				!!( elem.type || elem.href || ~elem.tabIndex );
1557		},
1558
1559		// Boolean properties
1560		enabled: createDisabledPseudo( false ),
1561		disabled: createDisabledPseudo( true ),
1562
1563		checked: function( elem ) {
1564
1565			// In CSS3, :checked should return both checked and selected elements
1566			// https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1567			return ( nodeName( elem, "input" ) && !!elem.checked ) ||
1568				( nodeName( elem, "option" ) && !!elem.selected );
1569		},
1570
1571		selected: function( elem ) {
1572
1573			// Support: IE <=11+
1574			// Accessing the selectedIndex property
1575			// forces the browser to treat the default option as
1576			// selected when in an optgroup.
1577			if ( isIE && elem.parentNode ) {
1578				// eslint-disable-next-line no-unused-expressions
1579				elem.parentNode.selectedIndex;
1580			}
1581
1582			return elem.selected === true;
1583		},
1584
1585		// Contents
1586		empty: function( elem ) {
1587
1588			// https://www.w3.org/TR/selectors/#empty-pseudo
1589			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
1590			//   but not by others (comment: 8; processing instruction: 7; etc.)
1591			// nodeType < 6 works because attributes (2) do not appear as children
1592			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1593				if ( elem.nodeType < 6 ) {
1594					return false;
1595				}
1596			}
1597			return true;
1598		},
1599
1600		parent: function( elem ) {
1601			return !Expr.pseudos.empty( elem );
1602		},
1603
1604		// Element/input types
1605		header: function( elem ) {
1606			return rheader.test( elem.nodeName );
1607		},
1608
1609		input: function( elem ) {
1610			return rinputs.test( elem.nodeName );
1611		},
1612
1613		button: function( elem ) {
1614			return nodeName( elem, "input" ) && elem.type === "button" ||
1615				nodeName( elem, "button" );
1616		},
1617
1618		text: function( elem ) {
1619			return nodeName( elem, "input" ) && elem.type === "text";
1620		},
1621
1622		// Position-in-collection
1623		first: createPositionalPseudo( function() {
1624			return [ 0 ];
1625		} ),
1626
1627		last: createPositionalPseudo( function( _matchIndexes, length ) {
1628			return [ length - 1 ];
1629		} ),
1630
1631		eq: createPositionalPseudo( function( _matchIndexes, length, argument ) {
1632			return [ argument < 0 ? argument + length : argument ];
1633		} ),
1634
1635		even: createPositionalPseudo( function( matchIndexes, length ) {
1636			var i = 0;
1637			for ( ; i < length; i += 2 ) {
1638				matchIndexes.push( i );
1639			}
1640			return matchIndexes;
1641		} ),
1642
1643		odd: createPositionalPseudo( function( matchIndexes, length ) {
1644			var i = 1;
1645			for ( ; i < length; i += 2 ) {
1646				matchIndexes.push( i );
1647			}
1648			return matchIndexes;
1649		} ),
1650
1651		lt: createPositionalPseudo( function( matchIndexes, length, argument ) {
1652			var i;
1653
1654			if ( argument < 0 ) {
1655				i = argument + length;
1656			} else if ( argument > length ) {
1657				i = length;
1658			} else {
1659				i = argument;
1660			}
1661
1662			for ( ; --i >= 0; ) {
1663				matchIndexes.push( i );
1664			}
1665			return matchIndexes;
1666		} ),
1667
1668		gt: createPositionalPseudo( function( matchIndexes, length, argument ) {
1669			var i = argument < 0 ? argument + length : argument;
1670			for ( ; ++i < length; ) {
1671				matchIndexes.push( i );
1672			}
1673			return matchIndexes;
1674		} )
1675	}
1676};
1677
1678Expr.pseudos.nth = Expr.pseudos.eq;
1679
1680// Add button/input type pseudos
1681for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
1682	Expr.pseudos[ i ] = createInputPseudo( i );
1683}
1684for ( i in { submit: true, reset: true } ) {
1685	Expr.pseudos[ i ] = createButtonPseudo( i );
1686}
1687
1688// Easy API for creating new setFilters
1689function setFilters() {}
1690setFilters.prototype = Expr.filters = Expr.pseudos;
1691Expr.setFilters = new setFilters();
1692
1693function tokenize( selector, parseOnly ) {
1694	var matched, match, tokens, type,
1695		soFar, groups, preFilters,
1696		cached = tokenCache[ selector + " " ];
1697
1698	if ( cached ) {
1699		return parseOnly ? 0 : cached.slice( 0 );
1700	}
1701
1702	soFar = selector;
1703	groups = [];
1704	preFilters = Expr.preFilter;
1705
1706	while ( soFar ) {
1707
1708		// Comma and first run
1709		if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
1710			if ( match ) {
1711
1712				// Don't consume trailing commas as valid
1713				soFar = soFar.slice( match[ 0 ].length ) || soFar;
1714			}
1715			groups.push( ( tokens = [] ) );
1716		}
1717
1718		matched = false;
1719
1720		// Combinators
1721		if ( ( match = rcombinators.exec( soFar ) ) ) {
1722			matched = match.shift();
1723			tokens.push( {
1724				value: matched,
1725
1726				// Cast descendant combinators to space
1727				type: match[ 0 ].replace( rtrim, " " )
1728			} );
1729			soFar = soFar.slice( matched.length );
1730		}
1731
1732		// Filters
1733		for ( type in Expr.filter ) {
1734			if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
1735				( match = preFilters[ type ]( match ) ) ) ) {
1736				matched = match.shift();
1737				tokens.push( {
1738					value: matched,
1739					type: type,
1740					matches: match
1741				} );
1742				soFar = soFar.slice( matched.length );
1743			}
1744		}
1745
1746		if ( !matched ) {
1747			break;
1748		}
1749	}
1750
1751	// Return the length of the invalid excess
1752	// if we're just parsing
1753	// Otherwise, throw an error or return tokens
1754	if ( parseOnly ) {
1755		return soFar.length;
1756	}
1757
1758	return soFar ?
1759		selectorError( selector ) :
1760
1761		// Cache the tokens
1762		tokenCache( selector, groups ).slice( 0 );
1763}
1764
1765function toSelector( tokens ) {
1766	var i = 0,
1767		len = tokens.length,
1768		selector = "";
1769	for ( ; i < len; i++ ) {
1770		selector += tokens[ i ].value;
1771	}
1772	return selector;
1773}
1774
1775function addCombinator( matcher, combinator, base ) {
1776	var dir = combinator.dir,
1777		skip = combinator.next,
1778		key = skip || dir,
1779		checkNonElements = base && key === "parentNode",
1780		doneName = done++;
1781
1782	return combinator.first ?
1783
1784		// Check against closest ancestor/preceding element
1785		function( elem, context, xml ) {
1786			while ( ( elem = elem[ dir ] ) ) {
1787				if ( elem.nodeType === 1 || checkNonElements ) {
1788					return matcher( elem, context, xml );
1789				}
1790			}
1791			return false;
1792		} :
1793
1794		// Check against all ancestor/preceding elements
1795		function( elem, context, xml ) {
1796			var oldCache, outerCache,
1797				newCache = [ dirruns, doneName ];
1798
1799			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
1800			if ( xml ) {
1801				while ( ( elem = elem[ dir ] ) ) {
1802					if ( elem.nodeType === 1 || checkNonElements ) {
1803						if ( matcher( elem, context, xml ) ) {
1804							return true;
1805						}
1806					}
1807				}
1808			} else {
1809				while ( ( elem = elem[ dir ] ) ) {
1810					if ( elem.nodeType === 1 || checkNonElements ) {
1811						outerCache = elem[ expando ] || ( elem[ expando ] = {} );
1812
1813						if ( skip && nodeName( elem, skip ) ) {
1814							elem = elem[ dir ] || elem;
1815						} else if ( ( oldCache = outerCache[ key ] ) &&
1816							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
1817
1818							// Assign to newCache so results back-propagate to previous elements
1819							return ( newCache[ 2 ] = oldCache[ 2 ] );
1820						} else {
1821
1822							// Reuse newcache so results back-propagate to previous elements
1823							outerCache[ key ] = newCache;
1824
1825							// A match means we're done; a fail means we have to keep checking
1826							if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
1827								return true;
1828							}
1829						}
1830					}
1831				}
1832			}
1833			return false;
1834		};
1835}
1836
1837function elementMatcher( matchers ) {
1838	return matchers.length > 1 ?
1839		function( elem, context, xml ) {
1840			var i = matchers.length;
1841			while ( i-- ) {
1842				if ( !matchers[ i ]( elem, context, xml ) ) {
1843					return false;
1844				}
1845			}
1846			return true;
1847		} :
1848		matchers[ 0 ];
1849}
1850
1851function multipleContexts( selector, contexts, results ) {
1852	var i = 0,
1853		len = contexts.length;
1854	for ( ; i < len; i++ ) {
1855		find( selector, contexts[ i ], results );
1856	}
1857	return results;
1858}
1859
1860function condense( unmatched, map, filter, context, xml ) {
1861	var elem,
1862		newUnmatched = [],
1863		i = 0,
1864		len = unmatched.length,
1865		mapped = map != null;
1866
1867	for ( ; i < len; i++ ) {
1868		if ( ( elem = unmatched[ i ] ) ) {
1869			if ( !filter || filter( elem, context, xml ) ) {
1870				newUnmatched.push( elem );
1871				if ( mapped ) {
1872					map.push( i );
1873				}
1874			}
1875		}
1876	}
1877
1878	return newUnmatched;
1879}
1880
1881function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
1882	if ( postFilter && !postFilter[ expando ] ) {
1883		postFilter = setMatcher( postFilter );
1884	}
1885	if ( postFinder && !postFinder[ expando ] ) {
1886		postFinder = setMatcher( postFinder, postSelector );
1887	}
1888	return markFunction( function( seed, results, context, xml ) {
1889		var temp, i, elem, matcherOut,
1890			preMap = [],
1891			postMap = [],
1892			preexisting = results.length,
1893
1894			// Get initial elements from seed or context
1895			elems = seed ||
1896				multipleContexts( selector || "*",
1897					context.nodeType ? [ context ] : context, [] ),
1898
1899			// Prefilter to get matcher input, preserving a map for seed-results synchronization
1900			matcherIn = preFilter && ( seed || !selector ) ?
1901				condense( elems, preMap, preFilter, context, xml ) :
1902				elems;
1903
1904		if ( matcher ) {
1905
1906			// If we have a postFinder, or filtered seed, or non-seed postFilter
1907			// or preexisting results,
1908			matcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
1909
1910				// ...intermediate processing is necessary
1911				[] :
1912
1913				// ...otherwise use results directly
1914				results;
1915
1916			// Find primary matches
1917			matcher( matcherIn, matcherOut, context, xml );
1918		} else {
1919			matcherOut = matcherIn;
1920		}
1921
1922		// Apply postFilter
1923		if ( postFilter ) {
1924			temp = condense( matcherOut, postMap );
1925			postFilter( temp, [], context, xml );
1926
1927			// Un-match failing elements by moving them back to matcherIn
1928			i = temp.length;
1929			while ( i-- ) {
1930				if ( ( elem = temp[ i ] ) ) {
1931					matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
1932				}
1933			}
1934		}
1935
1936		if ( seed ) {
1937			if ( postFinder || preFilter ) {
1938				if ( postFinder ) {
1939
1940					// Get the final matcherOut by condensing this intermediate into postFinder contexts
1941					temp = [];
1942					i = matcherOut.length;
1943					while ( i-- ) {
1944						if ( ( elem = matcherOut[ i ] ) ) {
1945
1946							// Restore matcherIn since elem is not yet a final match
1947							temp.push( ( matcherIn[ i ] = elem ) );
1948						}
1949					}
1950					postFinder( null, ( matcherOut = [] ), temp, xml );
1951				}
1952
1953				// Move matched elements from seed to results to keep them synchronized
1954				i = matcherOut.length;
1955				while ( i-- ) {
1956					if ( ( elem = matcherOut[ i ] ) &&
1957						( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) {
1958
1959						seed[ temp ] = !( results[ temp ] = elem );
1960					}
1961				}
1962			}
1963
1964		// Add elements to results, through postFinder if defined
1965		} else {
1966			matcherOut = condense(
1967				matcherOut === results ?
1968					matcherOut.splice( preexisting, matcherOut.length ) :
1969					matcherOut
1970			);
1971			if ( postFinder ) {
1972				postFinder( null, results, matcherOut, xml );
1973			} else {
1974				push.apply( results, matcherOut );
1975			}
1976		}
1977	} );
1978}
1979
1980function matcherFromTokens( tokens ) {
1981	var checkContext, matcher, j,
1982		len = tokens.length,
1983		leadingRelative = Expr.relative[ tokens[ 0 ].type ],
1984		implicitRelative = leadingRelative || Expr.relative[ " " ],
1985		i = leadingRelative ? 1 : 0,
1986
1987		// The foundational matcher ensures that elements are reachable from top-level context(s)
1988		matchContext = addCombinator( function( elem ) {
1989			return elem === checkContext;
1990		}, implicitRelative, true ),
1991		matchAnyContext = addCombinator( function( elem ) {
1992			return indexOf.call( checkContext, elem ) > -1;
1993		}, implicitRelative, true ),
1994		matchers = [ function( elem, context, xml ) {
1995			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
1996				( checkContext = context ).nodeType ?
1997					matchContext( elem, context, xml ) :
1998					matchAnyContext( elem, context, xml ) );
1999
2000			// Avoid hanging onto element (issue #299)
2001			checkContext = null;
2002			return ret;
2003		} ];
2004
2005	for ( ; i < len; i++ ) {
2006		if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
2007			matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
2008		} else {
2009			matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
2010
2011			// Return special upon seeing a positional matcher
2012			if ( matcher[ expando ] ) {
2013
2014				// Find the next relative operator (if any) for proper handling
2015				j = ++i;
2016				for ( ; j < len; j++ ) {
2017					if ( Expr.relative[ tokens[ j ].type ] ) {
2018						break;
2019					}
2020				}
2021				return setMatcher(
2022					i > 1 && elementMatcher( matchers ),
2023					i > 1 && toSelector(
2024
2025						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2026						tokens.slice( 0, i - 1 )
2027							.concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
2028					).replace( rtrim, "$1" ),
2029					matcher,
2030					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2031					j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
2032					j < len && toSelector( tokens )
2033				);
2034			}
2035			matchers.push( matcher );
2036		}
2037	}
2038
2039	return elementMatcher( matchers );
2040}
2041
2042function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2043	var bySet = setMatchers.length > 0,
2044		byElement = elementMatchers.length > 0,
2045		superMatcher = function( seed, context, xml, results, outermost ) {
2046			var elem, j, matcher,
2047				matchedCount = 0,
2048				i = "0",
2049				unmatched = seed && [],
2050				setMatched = [],
2051				contextBackup = outermostContext,
2052
2053				// We must always have either seed elements or outermost context
2054				elems = seed || byElement && Expr.find.TAG( "*", outermost ),
2055
2056				// Use integer dirruns iff this is the outermost matcher
2057				dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 );
2058
2059			if ( outermost ) {
2060
2061				// Support: IE 11+
2062				// IE sometimes throws a "Permission denied" error when strict-comparing
2063				// two documents; shallow comparisons work.
2064				// eslint-disable-next-line eqeqeq
2065				outermostContext = context == document || context || outermost;
2066			}
2067
2068			// Add elements passing elementMatchers directly to results
2069			for ( ; ( elem = elems[ i ] ) != null; i++ ) {
2070				if ( byElement && elem ) {
2071					j = 0;
2072
2073					// Support: IE 11+
2074					// IE sometimes throws a "Permission denied" error when strict-comparing
2075					// two documents; shallow comparisons work.
2076					// eslint-disable-next-line eqeqeq
2077					if ( !context && elem.ownerDocument != document ) {
2078						setDocument( elem );
2079						xml = !documentIsHTML;
2080					}
2081					while ( ( matcher = elementMatchers[ j++ ] ) ) {
2082						if ( matcher( elem, context || document, xml ) ) {
2083							push.call( results, elem );
2084							break;
2085						}
2086					}
2087					if ( outermost ) {
2088						dirruns = dirrunsUnique;
2089					}
2090				}
2091
2092				// Track unmatched elements for set filters
2093				if ( bySet ) {
2094
2095					// They will have gone through all possible matchers
2096					if ( ( elem = !matcher && elem ) ) {
2097						matchedCount--;
2098					}
2099
2100					// Lengthen the array for every element, matched or not
2101					if ( seed ) {
2102						unmatched.push( elem );
2103					}
2104				}
2105			}
2106
2107			// `i` is now the count of elements visited above, and adding it to `matchedCount`
2108			// makes the latter nonnegative.
2109			matchedCount += i;
2110
2111			// Apply set filters to unmatched elements
2112			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2113			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2114			// no element matchers and no seed.
2115			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2116			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2117			// numerically zero.
2118			if ( bySet && i !== matchedCount ) {
2119				j = 0;
2120				while ( ( matcher = setMatchers[ j++ ] ) ) {
2121					matcher( unmatched, setMatched, context, xml );
2122				}
2123
2124				if ( seed ) {
2125
2126					// Reintegrate element matches to eliminate the need for sorting
2127					if ( matchedCount > 0 ) {
2128						while ( i-- ) {
2129							if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
2130								setMatched[ i ] = pop.call( results );
2131							}
2132						}
2133					}
2134
2135					// Discard index placeholder values to get only actual matches
2136					setMatched = condense( setMatched );
2137				}
2138
2139				// Add matches to results
2140				push.apply( results, setMatched );
2141
2142				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2143				if ( outermost && !seed && setMatched.length > 0 &&
2144					( matchedCount + setMatchers.length ) > 1 ) {
2145
2146					jQuery.uniqueSort( results );
2147				}
2148			}
2149
2150			// Override manipulation of globals by nested matchers
2151			if ( outermost ) {
2152				dirruns = dirrunsUnique;
2153				outermostContext = contextBackup;
2154			}
2155
2156			return unmatched;
2157		};
2158
2159	return bySet ?
2160		markFunction( superMatcher ) :
2161		superMatcher;
2162}
2163
2164function compile( selector, match /* Internal Use Only */ ) {
2165	var i,
2166		setMatchers = [],
2167		elementMatchers = [],
2168		cached = compilerCache[ selector + " " ];
2169
2170	if ( !cached ) {
2171
2172		// Generate a function of recursive functions that can be used to check each element
2173		if ( !match ) {
2174			match = tokenize( selector );
2175		}
2176		i = match.length;
2177		while ( i-- ) {
2178			cached = matcherFromTokens( match[ i ] );
2179			if ( cached[ expando ] ) {
2180				setMatchers.push( cached );
2181			} else {
2182				elementMatchers.push( cached );
2183			}
2184		}
2185
2186		// Cache the compiled function
2187		cached = compilerCache( selector,
2188			matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2189
2190		// Save selector and tokenization
2191		cached.selector = selector;
2192	}
2193	return cached;
2194}
2195
2196/**
2197 * A low-level selection function that works with jQuery's compiled
2198 *  selector functions
2199 * @param {String|Function} selector A selector or a pre-compiled
2200 *  selector function built with jQuery selector compile
2201 * @param {Element} context
2202 * @param {Array} [results]
2203 * @param {Array} [seed] A set of elements to match against
2204 */
2205function select( selector, context, results, seed ) {
2206	var i, tokens, token, type, find,
2207		compiled = typeof selector === "function" && selector,
2208		match = !seed && tokenize( ( selector = compiled.selector || selector ) );
2209
2210	results = results || [];
2211
2212	// Try to minimize operations if there is only one selector in the list and no seed
2213	// (the latter of which guarantees us context)
2214	if ( match.length === 1 ) {
2215
2216		// Reduce context if the leading compound selector is an ID
2217		tokens = match[ 0 ] = match[ 0 ].slice( 0 );
2218		if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
2219				context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
2220
2221			context = ( Expr.find.ID(
2222				token.matches[ 0 ].replace( runescape, funescape ),
2223				context
2224			) || [] )[ 0 ];
2225			if ( !context ) {
2226				return results;
2227
2228			// Precompiled matchers will still verify ancestry, so step up a level
2229			} else if ( compiled ) {
2230				context = context.parentNode;
2231			}
2232
2233			selector = selector.slice( tokens.shift().value.length );
2234		}
2235
2236		// Fetch a seed set for right-to-left matching
2237		i = matchExpr.needsContext.test( selector ) ? 0 : tokens.length;
2238		while ( i-- ) {
2239			token = tokens[ i ];
2240
2241			// Abort if we hit a combinator
2242			if ( Expr.relative[ ( type = token.type ) ] ) {
2243				break;
2244			}
2245			if ( ( find = Expr.find[ type ] ) ) {
2246
2247				// Search, expanding context for leading sibling combinators
2248				if ( ( seed = find(
2249					token.matches[ 0 ].replace( runescape, funescape ),
2250					rsibling.test( tokens[ 0 ].type ) &&

2251						testContext( context.parentNode ) || context
2252				) ) ) {
2253
2254					// If seed is empty or no tokens remain, we can return early
2255					tokens.splice( i, 1 );
2256					selector = seed.length && toSelector( tokens );
2257					if ( !selector ) {
2258						push.apply( results, seed );
2259						return results;
2260					}
2261
2262					break;
2263				}
2264			}
2265		}
2266	}
2267
2268	// Compile and execute a filtering function if one is not provided
2269	// Provide `match` to avoid retokenization if we modified the selector above
2270	( compiled || compile( selector, match ) )(
2271		seed,
2272		context,
2273		!documentIsHTML,
2274		results,
2275		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2276	);
2277	return results;
2278}
2279
2280// Initialize against the default document
2281setDocument();
2282
2283jQuery.find = find;
2284
2285} )();
2286
2287function dir( elem, dir, until ) {
2288	var matched = [],
2289		truncate = until !== undefined;
2290
2291	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
2292		if ( elem.nodeType === 1 ) {
2293			if ( truncate && jQuery( elem ).is( until ) ) {
2294				break;
2295			}
2296			matched.push( elem );
2297		}
2298	}
2299	return matched;
2300}
2301
2302function siblings( n, elem ) {
2303	var matched = [];
2304
2305	for ( ; n; n = n.nextSibling ) {
2306		if ( n.nodeType === 1 && n !== elem ) {
2307			matched.push( n );
2308		}
2309	}
2310
2311	return matched;
2312}
2313
2314var rneedsContext = jQuery.expr.match.needsContext;
2315
2316// rsingleTag matches a string consisting of a single HTML element with no attributes
2317// and captures the element's name
2318var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
2319
2320// Implement the identical functionality for filter and not
2321function winnow( elements, qualifier, not ) {
2322	if ( typeof qualifier === "function" ) {
2323		return jQuery.grep( elements, function( elem, i ) {
2324			return !!qualifier.call( elem, i, elem ) !== not;
2325		} );
2326	}
2327
2328	// Single element
2329	if ( qualifier.nodeType ) {
2330		return jQuery.grep( elements, function( elem ) {
2331			return ( elem === qualifier ) !== not;
2332		} );
2333	}
2334
2335	// Arraylike of elements (jQuery, arguments, Array)
2336	if ( typeof qualifier !== "string" ) {
2337		return jQuery.grep( elements, function( elem ) {
2338			return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
2339		} );
2340	}
2341
2342	// Filtered directly for both simple and complex selectors
2343	return jQuery.filter( qualifier, elements, not );
2344}
2345
2346jQuery.filter = function( expr, elems, not ) {
2347	var elem = elems[ 0 ];
2348
2349	if ( not ) {
2350		expr = ":not(" + expr + ")";
2351	}
2352
2353	if ( elems.length === 1 && elem.nodeType === 1 ) {
2354		return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
2355	}
2356
2357	return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
2358		return elem.nodeType === 1;
2359	} ) );
2360};
2361
2362jQuery.fn.extend( {
2363	find: function( selector ) {
2364		var i, ret,
2365			len = this.length,
2366			self = this;
2367
2368		if ( typeof selector !== "string" ) {
2369			return this.pushStack( jQuery( selector ).filter( function() {
2370				for ( i = 0; i < len; i++ ) {
2371					if ( jQuery.contains( self[ i ], this ) ) {
2372						return true;
2373					}
2374				}
2375			} ) );
2376		}
2377
2378		ret = this.pushStack( [] );
2379
2380		for ( i = 0; i < len; i++ ) {
2381			jQuery.find( selector, self[ i ], ret );
2382		}
2383
2384		return len > 1 ? jQuery.uniqueSort( ret ) : ret;
2385	},
2386	filter: function( selector ) {
2387		return this.pushStack( winnow( this, selector || [], false ) );
2388	},
2389	not: function( selector ) {
2390		return this.pushStack( winnow( this, selector || [], true ) );
2391	},
2392	is: function( selector ) {
2393		return !!winnow(
2394			this,
2395
2396			// If this is a positional/relative selector, check membership in the returned set
2397			// so $("p:first").is("p:last") won't return true for a doc with two "p".
2398			typeof selector === "string" && rneedsContext.test( selector ) ?
2399				jQuery( selector ) :
2400				selector || [],
2401			false
2402		).length;
2403	}
2404} );
2405
2406// Initialize a jQuery object
2407
2408// A central reference to the root jQuery(document)
2409var rootjQuery,
2410
2411	// A simple way to check for HTML strings
2412	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
2413	// Strict HTML recognition (#11290: must start with <)
2414	// Shortcut simple #id case for speed
2415	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
2416
2417	init = jQuery.fn.init = function( selector, context, root ) {
2418		var match, elem;
2419
2420		// HANDLE: $(""), $(null), $(undefined), $(false)
2421		if ( !selector ) {
2422			return this;
2423		}
2424
2425		// Method init() accepts an alternate rootjQuery

2426		// so migrate can support jQuery.sub (gh-2101)
2427		root = root || rootjQuery;
2428
2429		// Handle HTML strings
2430		if ( typeof selector === "string" ) {
2431			if ( selector[ 0 ] === "<" &&
2432				selector[ selector.length - 1 ] === ">" &&
2433				selector.length >= 3 ) {
2434
2435				// Assume that strings that start and end with <> are HTML and skip the regex check
2436				match = [ null, selector, null ];
2437
2438			} else {
2439				match = rquickExpr.exec( selector );
2440			}
2441
2442			// Match html or make sure no context is specified for #id
2443			if ( match && ( match[ 1 ] || !context ) ) {
2444
2445				// HANDLE: $(html) -> $(array)
2446				if ( match[ 1 ] ) {
2447					context = context instanceof jQuery ? context[ 0 ] : context;
2448
2449					// Option to run scripts is true for back-compat
2450					// Intentionally let the error be thrown if parseHTML is not present
2451					jQuery.merge( this, jQuery.parseHTML(
2452						match[ 1 ],
2453						context && context.nodeType ? context.ownerDocument || context : document,
2454						true
2455					) );
2456
2457					// HANDLE: $(html, props)
2458					if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
2459						for ( match in context ) {
2460
2461							// Properties of context are called as methods if possible
2462							if ( typeof this[ match ] === "function" ) {
2463								this[ match ]( context[ match ] );
2464
2465							// ...and otherwise set as attributes
2466							} else {
2467								this.attr( match, context[ match ] );
2468							}
2469						}
2470					}
2471
2472					return this;
2473
2474				// HANDLE: $(#id)
2475				} else {
2476					elem = document.getElementById( match[ 2 ] );
2477
2478					if ( elem ) {
2479
2480						// Inject the element directly into the jQuery object
2481						this[ 0 ] = elem;
2482						this.length = 1;
2483					}
2484					return this;
2485				}
2486
2487			// HANDLE: $(expr, $(...))
2488			} else if ( !context || context.jquery ) {
2489				return ( context || root ).find( selector );
2490
2491			// HANDLE: $(expr, context)
2492			// (which is just equivalent to: $(context).find(expr)
2493			} else {
2494				return this.constructor( context ).find( selector );
2495			}
2496
2497		// HANDLE: $(DOMElement)
2498		} else if ( selector.nodeType ) {
2499			this[ 0 ] = selector;
2500			this.length = 1;
2501			return this;
2502
2503		// HANDLE: $(function)
2504		// Shortcut for document ready
2505		} else if ( typeof selector === "function" ) {
2506			return root.ready !== undefined ?
2507				root.ready( selector ) :
2508
2509				// Execute immediately if ready is not present
2510				selector( jQuery );
2511		}
2512
2513		return jQuery.makeArray( selector, this );
2514	};
2515
2516// Give the init function the jQuery prototype for later instantiation
2517init.prototype = jQuery.fn;
2518
2519// Initialize central reference
2520rootjQuery = jQuery( document );
2521
2522var rparentsprev = /^(?:parents|prev(?:Until|All))/,
2523
2524	// Methods guaranteed to produce a unique set when starting from a unique set
2525	guaranteedUnique = {
2526		children: true,
2527		contents: true,
2528		next: true,
2529		prev: true
2530	};
2531
2532jQuery.fn.extend( {
2533	has: function( target ) {
2534		var targets = jQuery( target, this ),
2535			l = targets.length;
2536
2537		return this.filter( function() {
2538			var i = 0;
2539			for ( ; i < l; i++ ) {
2540				if ( jQuery.contains( this, targets[ i ] ) ) {
2541					return true;
2542				}
2543			}
2544		} );
2545	},
2546
2547	closest: function( selectors, context ) {
2548		var cur,
2549			i = 0,
2550			l = this.length,
2551			matched = [],
2552			targets = typeof selectors !== "string" && jQuery( selectors );
2553
2554		// Positional selectors never match, since there's no _selection_ context
2555		if ( !rneedsContext.test( selectors ) ) {
2556			for ( ; i < l; i++ ) {
2557				for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
2558
2559					// Always skip document fragments
2560					if ( cur.nodeType < 11 && ( targets ?
2561						targets.index( cur ) > -1 :
2562
2563						// Don't pass non-elements to jQuery#find
2564						cur.nodeType === 1 &&
2565							jQuery.find.matchesSelector( cur, selectors ) ) ) {
2566
2567						matched.push( cur );
2568						break;
2569					}
2570				}
2571			}
2572		}
2573
2574		return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
2575	},
2576
2577	// Determine the position of an element within the set
2578	index: function( elem ) {
2579
2580		// No argument, return index in parent
2581		if ( !elem ) {
2582			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
2583		}
2584
2585		// Index in selector
2586		if ( typeof elem === "string" ) {
2587			return indexOf.call( jQuery( elem ), this[ 0 ] );
2588		}
2589
2590		// Locate the position of the desired element
2591		return indexOf.call( this,
2592
2593			// If it receives a jQuery object, the first element is used
2594			elem.jquery ? elem[ 0 ] : elem
2595		);
2596	},
2597
2598	add: function( selector, context ) {
2599		return this.pushStack(
2600			jQuery.uniqueSort(
2601				jQuery.merge( this.get(), jQuery( selector, context ) )
2602			)
2603		);
2604	},
2605
2606	addBack: function( selector ) {
2607		return this.add( selector == null ?
2608			this.prevObject : this.prevObject.filter( selector )
2609		);
2610	}
2611} );
2612
2613function sibling( cur, dir ) {
2614	while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
2615	return cur;
2616}
2617
2618jQuery.each( {
2619	parent: function( elem ) {
2620		var parent = elem.parentNode;
2621		return parent && parent.nodeType !== 11 ? parent : null;
2622	},
2623	parents: function( elem ) {
2624		return dir( elem, "parentNode" );
2625	},
2626	parentsUntil: function( elem, _i, until ) {
2627		return dir( elem, "parentNode", until );
2628	},
2629	next: function( elem ) {
2630		return sibling( elem, "nextSibling" );
2631	},
2632	prev: function( elem ) {
2633		return sibling( elem, "previousSibling" );
2634	},
2635	nextAll: function( elem ) {
2636		return dir( elem, "nextSibling" );
2637	},
2638	prevAll: function( elem ) {
2639		return dir( elem, "previousSibling" );
2640	},
2641	nextUntil: function( elem, _i, until ) {
2642		return dir( elem, "nextSibling", until );
2643	},
2644	prevUntil: function( elem, _i, until ) {
2645		return dir( elem, "previousSibling", until );
2646	},
2647	siblings: function( elem ) {
2648		return siblings( ( elem.parentNode || {} ).firstChild, elem );
2649	},
2650	children: function( elem ) {
2651		return siblings( elem.firstChild );
2652	},
2653	contents: function( elem ) {
2654		if ( elem.contentDocument != null &&
2655
2656			// Support: IE 11+
2657			// <object> elements with no `data` attribute has an object
2658			// `contentDocument` with a `null` prototype.
2659			getProto( elem.contentDocument ) ) {
2660
2661			return elem.contentDocument;
2662		}
2663
2664		// Support: IE 9 - 11+
2665		// Treat the template element as a regular one in browsers that
2666		// don't support it.
2667		if ( nodeName( elem, "template" ) ) {
2668			elem = elem.content || elem;
2669		}
2670
2671		return jQuery.merge( [], elem.childNodes );
2672	}
2673}, function( name, fn ) {
2674	jQuery.fn[ name ] = function( until, selector ) {
2675		var matched = jQuery.map( this, fn, until );
2676
2677		if ( name.slice( -5 ) !== "Until" ) {
2678			selector = until;
2679		}
2680
2681		if ( selector && typeof selector === "string" ) {
2682			matched = jQuery.filter( selector, matched );
2683		}
2684
2685		if ( this.length > 1 ) {
2686
2687			// Remove duplicates
2688			if ( !guaranteedUnique[ name ] ) {
2689				jQuery.uniqueSort( matched );
2690			}
2691
2692			// Reverse order for parents* and prev-derivatives
2693			if ( rparentsprev.test( name ) ) {
2694				matched.reverse();
2695			}
2696		}
2697
2698		return this.pushStack( matched );
2699	};
2700} );
2701
2702// Only count HTML whitespace
2703// Other whitespace should count in values
2704// https://infra.spec.whatwg.org/#ascii-whitespace
2705var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g