https://www.euyansang.com.sg/on/demandware.static/Sites-EYS-Site/-/en_SG/v1790229921292/js/main.js

1/******/ (function(modules) { // webpackBootstrap
2/******/ 	// The module cache
3/******/ 	var installedModules = {};
4/******/
5/******/ 	// The require function
6/******/ 	function __webpack_require__(moduleId) {
7/******/
8/******/ 		// Check if module is in cache
9/******/ 		if(installedModules[moduleId]) {
10/******/ 			return installedModules[moduleId].exports;
11/******/ 		}
12/******/ 		// Create a new module (and put it into the cache)
13/******/ 		var module = installedModules[moduleId] = {
14/******/ 			i: moduleId,
15/******/ 			l: false,
16/******/ 			exports: {}
17/******/ 		};
18/******/
19/******/ 		// Execute the module function
20/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
21/******/
22/******/ 		// Flag the module as loaded
23/******/ 		module.l = true;
24/******/
25/******/ 		// Return the exports of the module
26/******/ 		return module.exports;
27/******/ 	}
28/******/
29/******/
30/******/ 	// expose the modules object (__webpack_modules__)
31/******/ 	__webpack_require__.m = modules;
32/******/
33/******/ 	// expose the module cache
34/******/ 	__webpack_require__.c = installedModules;
35/******/
36/******/ 	// define getter function for harmony exports
37/******/ 	__webpack_require__.d = function(exports, name, getter) {
38/******/ 		if(!__webpack_require__.o(exports, name)) {
39/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
40/******/ 		}
41/******/ 	};
42/******/
43/******/ 	// define __esModule on exports
44/******/ 	__webpack_require__.r = function(exports) {
45/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
46/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
47/******/ 		}
48/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
49/******/ 	};
50/******/
51/******/ 	// create a fake namespace object
52/******/ 	// mode & 1: value is a module id, require it
53/******/ 	// mode & 2: merge all properties of value into the ns
54/******/ 	// mode & 4: return value when already ns object
55/******/ 	// mode & 8|1: behave like require
56/******/ 	__webpack_require__.t = function(value, mode) {
57/******/ 		if(mode & 1) value = __webpack_require__(value);
58/******/ 		if(mode & 8) return value;
59/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
60/******/ 		var ns = Object.create(null);
61/******/ 		__webpack_require__.r(ns);
62/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
63/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
64/******/ 		return ns;
65/******/ 	};
66/******/
67/******/ 	// getDefaultExport function for compatibility with non-harmony modules
68/******/ 	__webpack_require__.n = function(module) {
69/******/ 		var getter = module && module.__esModule ?
70/******/ 			function getDefault() { return module['default']; } :
71/******/ 			function getModuleExports() { return module; };
72/******/ 		__webpack_require__.d(getter, 'a', getter);
73/******/ 		return getter;
74/******/ 	};
75/******/
76/******/ 	// Object.prototype.hasOwnProperty.call
77/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
78/******/
79/******/ 	// __webpack_public_path__
80/******/ 	__webpack_require__.p = "";
81/******/
82/******/
83/******/ 	// Load entry module and return exports
84/******/ 	return __webpack_require__(__webpack_require__.s = 274);
85/******/ })
86/************************************************************************/
87/******/ ({
88
89/***/ 11:
90/***/ (function(module, exports, __webpack_require__) {
91
92"use strict";
93
94
95module.exports = function (element) {
96    var position = element && element.length ? element.offset().top : 0;
97    $('html, body').animate({
98        scrollTop: position
99    }, 500);
100    if (!element) {
101        $('.logo-home').focus();
102    }
103};
104
105
106/***/ }),
107
108/***/ 20:
109/***/ (function(module, exports) {
110
111var g;
112
113// This works in non-strict mode
114g = (function() {
115	return this;
116})();
117
118try {
119	// This works if eval is allowed (see CSP)
120	g = g || new Function("return this")();
121} catch (e) {
122	// This works if the window reference is available
123	if (typeof window === "object") g = window;
124}
125
126// g can still be undefined, but nothing to do about it...
127// We return undefined, instead of nothing here, so it's
128// easier to handle this case. if(!global) { ...}
129
130module.exports = g;
131
132
133/***/ }),
134
135/***/ 258:

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