https://www.parcel2go.com/bundles/scripts/common?v=7aJFkWUzg1vm5vVbzryMx5Qrv_yeGymdEQOzHxxf1Uo1

1/* Minification failed. Returning unminified contents.
2(11927,15-16): run-time error JS1010: Expected identifier: .
3(11927,15-16): run-time error JS1195: Expected expression: .
4(16518,15-16): run-time error JS1010: Expected identifier: .
5(16518,15-16): run-time error JS1195: Expected expression: .
6(17049,15-16): run-time error JS1010: Expected identifier: .
7(17049,15-16): run-time error JS1195: Expected expression: .
8(17388,6): run-time error JS1004: Expected ';'
9(17389,67): run-time error JS1004: Expected ';'
10(17552,16-17): run-time error JS1195: Expected expression: .
11(17552,36-37): run-time error JS1195: Expected expression: .
12(17552,55-56): run-time error JS1003: Expected ':': )
13(17553,9-21): run-time error JS1009: Expected '}': customParams
14(17553,9-21): run-time error JS1003: Expected ':': customParams
15(17553,21-22): run-time error JS1195: Expected expression: .
16(17553,64-65): run-time error JS1006: Expected ')': ;
17(17557,16-17): run-time error JS1195: Expected expression: .
18(17557,36-37): run-time error JS1195: Expected expression: .
19(17557,57-58): run-time error JS1003: Expected ':': )
20(17558,9-21): run-time error JS1009: Expected '}': customParams
21(17558,9-21): run-time error JS1003: Expected ':': customParams
22(17558,21-22): run-time error JS1195: Expected expression: .
23(17558,88-89): run-time error JS1006: Expected ')': ;
24(17560,5-6): run-time error JS1002: Syntax error: }
25(17562,1-2): run-time error JS1002: Syntax error: }
26(17564,6): run-time error JS1004: Expected ';'
27(17588,27): run-time error JS1004: Expected ';'
28(17589,17): run-time error JS1004: Expected ';'
29(17591,25-33): run-time error JS1006: Expected ')': function
30(17591,36): run-time error JS1004: Expected ';'
31(17629,10): run-time error JS1004: Expected ';'
32(17630,2-3): run-time error JS1195: Expected expression: )
33(17561,5-24): run-time error JS1018: 'return' statement outside of function: return customParams
34 */
35/*!
36 * jQuery JavaScript Library v3.5.1
37 * https://jquery.com/
38 *
39 * Includes Sizzle.js
40 * https://sizzlejs.com/
41 *
42 * Copyright JS Foundation and other contributors
43 * Released under the MIT license
44 * https://jquery.org/license
45 *
46 * Date: 2020-05-04T22:49Z
47 */
48(function (global, factory) {
49
50	"use strict";
51
52	if (typeof module === "object" && typeof module.exports === "object") {
53
54		// For CommonJS and CommonJS-like environments where a proper `window`
55		// is present, execute the factory and get jQuery.
56		// For environments that do not have a `window` with a `document`
57		// (such as Node.js), expose a factory as module.exports.
58		// This accentuates the need for the creation of a real `window`.
59		// e.g. var jQuery = require("jquery")(window);
60		// See ticket #14549 for more info.
61		module.exports = global.document ?
62			factory(global, true) :
63			function (w) {
64				if (!w.document) {
65					throw new Error("jQuery requires a window with a document");
66				}
67				return factory(w);
68			};
69	} else {
70		factory(global);
71	}
72
73	// Pass this if window is not defined yet
74})(typeof window !== "undefined" ? window : this, function (window, noGlobal) {
75
76	// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
77	// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
78	// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
79	// enough that all such attempts are guarded in a try block.
80	"use strict";
81
82	var arr = [];
83
84	var getProto = Object.getPrototypeOf;
85
86	var slice = arr.slice;
87
88	var flat = arr.flat ? function (array) {
89		return arr.flat.call(array);
90	} : function (array) {
91		return arr.concat.apply([], array);
92	};
93
94
95	var push = arr.push;
96
97	var indexOf = arr.indexOf;
98
99	var class2type = {};
100
101	var toString = class2type.toString;
102
103	var hasOwn = class2type.hasOwnProperty;
104
105	var fnToString = hasOwn.toString;
106
107	var ObjectFunctionString = fnToString.call(Object);
108
109	var support = {};
110
111	var isFunction = function isFunction(obj) {
112
113		// Support: Chrome <=57, Firefox <=52
114		// In some browsers, typeof returns "function" for HTML <object> elements
115		// (i.e., `typeof document.createElement( "object" ) === "function"`).
116		// We don't want to classify *any* DOM node as a function.
117		return typeof obj === "function" && typeof obj.nodeType !== "number";
118	};
119
120
121	var isWindow = function isWindow(obj) {
122		return obj != null && obj === obj.window;
123	};
124
125
126	var document = window.document;
127
128
129
130	var preservedScriptAttributes = {
131		type: true,
132		src: true,
133		nonce: true,
134		noModule: true
135	};
136
137	function DOMEval(code, node, doc) {
138		doc = doc || document;
139
140		var i, val,
141			script = doc.createElement("script");
142
143		script.text = code;
144		if (node) {
145			for (i in preservedScriptAttributes) {
146
147				// Support: Firefox 64+, Edge 18+
148				// Some browsers don't support the "nonce" property on scripts.
149				// On the other hand, just using `getAttribute` is not enough as
150				// the `nonce` attribute is reset to an empty string whenever it
151				// becomes browsing-context connected.
152				// See https://github.com/whatwg/html/issues/2369
153				// See https://html.spec.whatwg.org/#nonce-attributes
154				// The `node.getAttribute` check was added for the sake of
155				// `jQuery.globalEval` so that it can fake a nonce-containing node
156				// via an object.
157				val = node[i] || node.getAttribute && node.getAttribute(i);
158				if (val) {
159					script.setAttribute(i, val);
160				}
161			}
162		}
163		doc.head.appendChild(script).parentNode.removeChild(script);
164	}
165
166
167	function toType(obj) {
168		if (obj == null) {
169			return obj + "";
170		}
171
172		// Support: Android <=2.3 only (functionish RegExp)
173		return typeof obj === "object" || typeof obj === "function" ?
174			class2type[toString.call(obj)] || "object" :
175			typeof obj;
176	}
177	/* global Symbol */
178	// Defining this global in .eslintrc.json would create a danger of using the global
179	// unguarded in another place, it seems safer to define global only for this module
180
181
182
183	var
184		version = "3.5.1",
185
186		// Define a local copy of jQuery
187		jQuery = function (selector, context) {
188
189			// The jQuery object is actually just the init constructor 'enhanced'
190			// Need init if jQuery is called (just allow error to be thrown if not included)
191			return new jQuery.fn.init(selector, context);
192		};
193
194	jQuery.fn = jQuery.prototype = {
195
196		// The current version of jQuery being used
197		jquery: version,
198
199		constructor: jQuery,
200
201		// The default length of a jQuery object is 0
202		length: 0,
203
204		toArray: function () {
205			return slice.call(this);
206		},
207
208		// Get the Nth element in the matched element set OR
209		// Get the whole matched element set as a clean array
210		get: function (num) {
211
212			// Return all the elements in a clean array
213			if (num == null) {
214				return slice.call(this);
215			}
216
217			// Return just the one element from the set
218			return num < 0 ? this[num + this.length] : this[num];
219		},
220
221		// Take an array of elements and push it onto the stack
222		// (returning the new matched element set)
223		pushStack: function (elems) {
224
225			// Build a new jQuery matched element set
226			var ret = jQuery.merge(this.constructor(), elems);
227
228			// Add the old object onto the stack (as a reference)
229			ret.prevObject = this;
230
231			// Return the newly-formed element set
232			return ret;
233		},
234
235		// Execute a callback for every element in the matched set.
236		each: function (callback) {
237			return jQuery.each(this, callback);
238		},
239
240		map: function (callback) {
241			return this.pushStack(jQuery.map(this, function (elem, i) {
242				return callback.call(elem, i, elem);
243			}));
244		},
245
246		slice: function () {
247			return this.pushStack(slice.apply(this, arguments));
248		},
249
250		first: function () {
251			return this.eq(0);
252		},
253
254		last: function () {
255			return this.eq(-1);
256		},
257
258		even: function () {
259			return this.pushStack(jQuery.grep(this, function (_elem, i) {
260				return (i + 1) % 2;
261			}));
262		},
263
264		odd: function () {
265			return this.pushStack(jQuery.grep(this, function (_elem, i) {
266				return i % 2;
267			}));
268		},
269
270		eq: function (i) {
271			var len = this.length,
272				j = +i + (i < 0 ? len : 0);
273			return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
274		},
275
276		end: function () {
277			return this.prevObject || this.constructor();
278		},
279
280		// For internal use only.
281		// Behaves like an Array's method, not like a jQuery method.
282		push: push,
283		sort: arr.sort,
284		splice: arr.splice
285	};
286
287	jQuery.extend = jQuery.fn.extend = function () {
288		var options, name, src, copy, copyIsArray, clone,
289			target = arguments[0] || {},
290			i = 1,
291			length = arguments.length,
292			deep = false;
293
294		// Handle a deep copy situation
295		if (typeof target === "boolean") {
296			deep = target;
297
298			// Skip the boolean and the target
299			target = arguments[i] || {};
300			i++;
301		}
302
303		// Handle case when target is a string or something (possible in deep copy)
304		if (typeof target !== "object" && !isFunction(target)) {
305			target = {};
306		}
307
308		// Extend jQuery itself if only one argument is passed
309		if (i === length) {
310			target = this;
311			i--;
312		}
313
314		for (; i < length; i++) {
315
316			// Only deal with non-null/undefined values
317			if ((options = arguments[i]) != null) {
318
319				// Extend the base object
320				for (name in options) {
321					copy = options[name];
322
323					// Prevent Object.prototype pollution
324					// Prevent never-ending loop
325					if (name === "__proto__" || target === copy) {
326						continue;
327					}
328
329					// Recurse if we're merging plain objects or arrays
330					if (deep && copy && (jQuery.isPlainObject(copy) ||
331						(copyIsArray = Array.isArray(copy)))) {
332						src = target[name];
333
334						// Ensure proper type for the source value
335						if (copyIsArray && !Array.isArray(src)) {
336							clone = [];
337						} else if (!copyIsArray && !jQuery.isPlainObject(src)) {
338							clone = {};
339						} else {
340							clone = src;
341						}
342						copyIsArray = false;
343
344						// Never move original objects, clone them
345						target[name] = jQuery.extend(deep, clone, copy);
346
347						// Don't bring in undefined values
348					} else if (copy !== undefined) {
349						target[name] = copy;
350					}
351				}
352			}
353		}
354
355		// Return the modified object
356		return target;
357	};
358
359	jQuery.extend({
360
361		// Unique for each copy of jQuery on the page
362		expando: "jQuery" + (version + Math.random()).replace(/\D/g, ""),
363
364		// Assume jQuery is ready without the ready module
365		isReady: true,
366
367		error: function (msg) {
368			throw new Error(msg);
369		},
370

371		noop: function () { },
372
373		isPlainObject: function (obj) {
374			var proto, Ctor;
375
376			// Detect obvious negatives
377			// Use toString instead of jQuery.type to catch host objects
378			if (!obj || toString.call(obj) !== "[object Object]") {
379				return false;
380			}
381
382			proto = getProto(obj);
383
384			// Objects with no prototype (e.g., `Object.create( null )`) are plain
385			if (!proto) {
386				return true;
387			}
388
389			// Objects with prototype are plain iff they were constructed by a global Object function
390			Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
391			return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
392		},
393
394		isEmptyObject: function (obj) {
395			var name;
396
397			for (name in obj) {
398				return false;
399			}
400			return true;
401		},
402
403		// Evaluates a script in a provided context; falls back to the global one
404		// if not specified.
405		globalEval: function (code, options, doc) {
406			DOMEval(code, { nonce: options && options.nonce }, doc);
407		},
408
409		each: function (obj, callback) {
410			var length, i = 0;
411
412			if (isArrayLike(obj)) {
413				length = obj.length;
414				for (; i < length; i++) {
415					if (callback.call(obj[i], i, obj[i]) === false) {
416						break;
417					}
418				}
419			} else {
420				for (i in obj) {
421					if (callback.call(obj[i], i, obj[i]) === false) {
422						break;
423					}
424				}
425			}
426
427			return obj;
428		},
429
430		// results is for internal usage only
431		makeArray: function (arr, results) {
432			var ret = results || [];
433
434			if (arr != null) {
435				if (isArrayLike(Object(arr))) {
436					jQuery.merge(ret,
437						typeof arr === "string" ?
438							[arr] : arr
439					);
440				} else {
441					push.call(ret, arr);
442				}
443			}
444
445			return ret;
446		},
447
448		inArray: function (elem, arr, i) {
449			return arr == null ? -1 : indexOf.call(arr, elem, i);
450		},
451
452		// Support: Android <=4.0 only, PhantomJS 1 only
453		// push.apply(_, arraylike) throws on ancient WebKit
454		merge: function (first, second) {
455			var len = +second.length,
456				j = 0,
457				i = first.length;
458
459			for (; j < len; j++) {
460				first[i++] = second[j];
461			}
462
463			first.length = i;
464
465			return first;
466		},
467
468		grep: function (elems, callback, invert) {
469			var callbackInverse,
470				matches = [],
471				i = 0,
472				length = elems.length,
473				callbackExpect = !invert;
474
475			// Go through the array, only saving the items
476			// that pass the validator function
477			for (; i < length; i++) {
478				callbackInverse = !callback(elems[i], i);
479				if (callbackInverse !== callbackExpect) {
480					matches.push(elems[i]);
481				}
482			}
483
484			return matches;
485		},
486
487		// arg is for internal usage only
488		map: function (elems, callback, arg) {
489			var length, value,
490				i = 0,
491				ret = [];
492
493			// Go through the array, translating each of the items to their new values
494			if (isArrayLike(elems)) {
495				length = elems.length;
496				for (; i < length; i++) {
497					value = callback(elems[i], i, arg);
498
499					if (value != null) {
500						ret.push(value);
501					}
502				}
503
504				// Go through every key on the object,
505			} else {
506				for (i in elems) {
507					value = callback(elems[i], i, arg);
508
509					if (value != null) {
510						ret.push(value);
511					}
512				}
513			}
514
515			// Flatten any nested arrays
516			return flat(ret);
517		},
518
519		// A global GUID counter for objects
520		guid: 1,
521
522		// jQuery.support is not used in Core but other projects attach their
523		// properties to it so it needs to exist.
524		support: support
525	});
526
527	if (typeof Symbol === "function") {
528		jQuery.fn[Symbol.iterator] = arr[Symbol.iterator];
529	}
530
531	// Populate the class2type map
532	jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),
533		function (_i, name) {
534			class2type["[object " + name + "]"] = name.toLowerCase();
535		});
536
537	function isArrayLike(obj) {
538
539		// Support: real iOS 8.2 only (not reproducible in simulator)
540		// `in` check used to prevent JIT error (gh-2145)
541		// hasOwn isn't used here due to false negatives
542		// regarding Nodelist length in IE
543		var length = !!obj && "length" in obj && obj.length,
544			type = toType(obj);
545
546		if (isFunction(obj) || isWindow(obj)) {
547			return false;
548		}
549
550		return type === "array" || length === 0 ||
551			typeof length === "number" && length > 0 && (length - 1) in obj;
552	}
553	var Sizzle =
554		/*!
555		 * Sizzle CSS Selector Engine v2.3.5
556		 * https://sizzlejs.com/
557		 *
558		 * Copyright JS Foundation and other contributors
559		 * Released under the MIT license
560		 * https://js.foundation/
561		 *
562		 * Date: 2020-03-14
563		 */
564		(function (window) {
565			var i,
566				support,
567				Expr,
568				getText,
569				isXML,
570				tokenize,
571				compile,
572				select,
573				outermostContext,
574				sortInput,
575				hasDuplicate,
576
577				// Local document vars
578				setDocument,
579				document,
580				docElem,
581				documentIsHTML,
582				rbuggyQSA,
583				rbuggyMatches,
584				matches,
585				contains,
586
587				// Instance-specific data
588				expando = "sizzle" + 1 * new Date(),
589				preferredDoc = window.document,
590				dirruns = 0,
591				done = 0,
592				classCache = createCache(),
593				tokenCache = createCache(),
594				compilerCache = createCache(),
595				nonnativeSelectorCache = createCache(),
596				sortOrder = function (a, b) {
597					if (a === b) {
598						hasDuplicate = true;
599					}
600					return 0;
601				},
602
603				// Instance methods
604				hasOwn = ({}).hasOwnProperty,
605				arr = [],
606				pop = arr.pop,
607				pushNative = arr.push,
608				push = arr.push,
609				slice = arr.slice,
610
611				// Use a stripped-down indexOf as it's faster than native
612				// https://jsperf.com/thor-indexof-vs-for/5
613				indexOf = function (list, elem) {
614					var i = 0,
615						len = list.length;
616					for (; i < len; i++) {
617						if (list[i] === elem) {
618							return i;
619						}
620					}
621					return -1;
622				},
623
624				booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
625					"ismap|loop|multiple|open|readonly|required|scoped",
626
627				// Regular expressions
628
629				// http://www.w3.org/TR/css3-selectors/#whitespace
630				whitespace = "[\\x20\\t\\r\\n\\f]",
631
632				// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
633				identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
634					"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
635
636				// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
637				attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
638
639					// Operator (capture 2)
640					"*([*^$|!~]?=)" + whitespace +
641
642					// "Attribute values must be CSS identifiers [capture 5]
643					// or strings [capture 3 or capture 4]"
644					"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
645					whitespace + "*\\]",
646
647				pseudos = ":(" + identifier + ")(?:\\((" +
648
649					// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
650					// 1. quoted (capture 3; capture 4 or capture 5)
651					"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
652
653					// 2. simple (capture 6)
654					"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
655
656					// 3. anything else (capture 2)
657					".*" +
658					")\\)|)",
659
660				// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
661				rwhitespace = new RegExp(whitespace + "+", "g"),
662				rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
663					whitespace + "+$", "g"),
664
665				rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"),
666				rcombinators = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
667					"*"),
668				rdescend = new RegExp(whitespace + "|>"),
669
670				rpseudo = new RegExp(pseudos),
671				ridentifier = new RegExp("^" + identifier + "$"),
672
673				matchExpr = {
674					"ID": new RegExp("^#(" + identifier + ")"),
675					"CLASS": new RegExp("^\\.(" + identifier + ")"),
676					"TAG": new RegExp("^(" + identifier + "|[*])"),
677					"ATTR": new RegExp("^" + attributes),
678					"PSEUDO": new RegExp("^" + pseudos),
679					"CHILD": new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
680						whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
681						whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i"),
682					"bool": new RegExp("^(?:" + booleans + ")$", "i"),
683
684					// For use in libraries implementing .is()
685					// We use this for POS matching in `select`
686					"needsContext": new RegExp("^" + whitespace +
687						"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
688						"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
689				},
690
691				rhtml = /HTML$/i,
692				rinputs = /^(?:input|select|textarea|button)$/i,
693				rheader = /^h\d$/i,
694
695				rnative = /^[^{]+\{\s*\[native \w/,
696
697				// Easily-parseable/retrievable ID or TAG or CLASS selectors
698				rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
699
700				rsibling = /[+~]/,
701
702				// CSS escapes
703				// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
704				runescape = new RegExp("\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g"),
705				funescape = function (escape, nonHex) {
706					var high = "0x" + escape.slice(1) - 0x10000;
707
708					return nonHex ?
709
710						// Strip the backslash prefix from a non-hex escape sequence
711						nonHex :
712
713						// Replace a hexadecimal escape sequence with the encoded Unicode code point
714						// Support: IE <=11+
715						// For values outside the Basic Multilingual Plane (BMP), manually construct a
716						// surrogate pair
717						high < 0 ?
718							String.fromCharCode(high + 0x10000) :
719							String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);
720				},
721
722				// CSS string/identifier serialization
723				// https://drafts.csswg.org/cssom/#common-serializing-idioms
724				rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
725				fcssescape = function (ch, asCodePoint) {
726					if (asCodePoint) {
727
728						// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
729						if (ch === "\0") {
730							return "\uFFFD";
731						}
732
733						// Control characters and (dependent upon position) numbers get escaped as code points
734						return ch.slice(0, -1) + "\\" +
735							ch.charCodeAt(ch.length - 1).toString(16) + " ";
736					}
737
738					// Other potentially-special ASCII characters get backslash-escaped
739					return "\\" + ch;
740				},
741
742				// Used for iframes
743				// See setDocument()
744				// Removing the function wrapper causes a "Permission Denied"
745				// error in IE
746				unloadHandler = function () {
747					setDocument();
748				},
749
750				inDisabledFieldset = addCombinator(
751					function (elem) {
752						return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
753					},
754					{ dir: "parentNode", next: "legend" }
755				);
756
757			// Optimize for push.apply( _, NodeList )
758			try {
759				push.apply(
760					(arr = slice.call(preferredDoc.childNodes)),
761					preferredDoc.childNodes
762				);
763
764				// Support: Android<4.0
765				// Detect silently failing push.apply
766				// eslint-disable-next-line no-unused-expressions
767				arr[preferredDoc.childNodes.length].nodeType;
768			} catch (e) {
769				push = {
770					apply: arr.length ?
771
772						// Leverage slice if possible
773						function (target, els) {
774							pushNative.apply(target, slice.call(els));
775						} :
776
777						// Support: IE<9
778						// Otherwise append directly
779						function (target, els) {
780							var j = target.length,
781								i = 0;
782
783							// Can't trust NodeList.length
784							while ((target[j++] = els[i++])) { }
785							target.length = j - 1;
786						}
787				};
788			}
789
790			function Sizzle(selector, context, results, seed) {
791				var m, i, elem, nid, match, groups, newSelector,
792					newContext = context && context.ownerDocument,
793
794					// nodeType defaults to 9, since context defaults to document
795					nodeType = context ? context.nodeType : 9;
796
797				results = results || [];
798
799				// Return early from calls with invalid selector or context
800				if (typeof selector !== "string" || !selector ||
801					nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {
802
803					return results;
804				}
805
806				// Try to shortcut find operations (as opposed to filters) in HTML documents
807				if (!seed) {
808					setDocument(context);
809					context = context || document;
810
811					if (documentIsHTML) {
812
813						// If the selector is sufficiently simple, try using a "get*By*" DOM method
814						// (excepting DocumentFragment context, where the methods don't exist)
815						if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {
816
817							// ID selector
818							if ((m = match[1])) {
819
820								// Document context
821								if (nodeType === 9) {
822									if ((elem = context.getElementById(m))) {
823
824										// Support: IE, Opera, Webkit
825										// TODO: identify versions
826										// getElementById can match elements by name instead of ID
827										if (elem.id === m) {
828											results.push(elem);
829											return results;
830										}
831									} else {
832										return results;
833									}
834
835									// Element context
836								} else {
837
838									// Support: IE, Opera, Webkit
839									// TODO: identify versions
840									// getElementById can match elements by name instead of ID
841									if (newContext && (elem = newContext.getElementById(m)) &&
842										contains(context, elem) &&
843										elem.id === m) {
844
845										results.push(elem);
846										return results;
847									}
848								}
849
850								// Type selector
851							} else if (match[2]) {
852								push.apply(results, context.getElementsByTagName(selector));
853								return results;
854
855								// Class selector
856							} else if ((m = match[3]) && support.getElementsByClassName &&
857								context.getElementsByClassName) {
858
859								push.apply(results, context.getElementsByClassName(m));
860								return results;
861							}
862						}
863
864						// Take advantage of querySelectorAll
865						if (support.qsa &&
866							!nonnativeSelectorCache[selector + " "] &&
867							(!rbuggyQSA || !rbuggyQSA.test(selector)) &&
868

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