https://wakufuri.com/hp/wp-content/themes/wakufuri/js/main.js

29/***/ "./node_modules/jquery/dist/jquery.js":
30/*!********************************************!*\
31  !*** ./node_modules/jquery/dist/jquery.js ***!
32  \********************************************/
33/***/ (function(module, exports) {
34
35var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
36 * jQuery JavaScript Library v3.7.0
37 * https://jquery.com/
38 *
39 * Copyright OpenJS Foundation and other contributors
40 * Released under the MIT license
41 * https://jquery.org/license
42 *
43 * Date: 2023-05-11T18:29Z
44 */
45( function( global, factory ) {
46
47	"use strict";
48
49	if (  true && typeof module.exports === "object" ) {
50
51		// For CommonJS and CommonJS-like environments where a proper `window`
52		// is present, execute the factory and get jQuery.
53		// For environments that do not have a `window` with a `document`
54		// (such as Node.js), expose a factory as module.exports.
55		// This accentuates the need for the creation of a real `window`.
56		// e.g. var jQuery = require("jquery")(window);
57		// See ticket trac-14549 for more info.
58		module.exports = global.document ?
59			factory( global, true ) :
60			function( w ) {
61				if ( !w.document ) {
62					throw new Error( "jQuery requires a window with a document" );
63				}
64				return factory( w );
65			};
66	} else {
67		factory( global );
68	}
69
70// Pass this if window is not defined yet
71} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
72
73// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
74// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
75// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
76// enough that all such attempts are guarded in a try block.
77"use strict";
78
79var arr = [];
80
81var getProto = Object.getPrototypeOf;
82
83var slice = arr.slice;
84
85var flat = arr.flat ? function( array ) {
86	return arr.flat.call( array );
87} : function( array ) {
88	return arr.concat.apply( [], array );
89};
90
91
92var push = arr.push;
93
94var indexOf = arr.indexOf;
95
96var class2type = {};
97
98var toString = class2type.toString;
99
100var hasOwn = class2type.hasOwnProperty;
101
102var fnToString = hasOwn.toString;
103
104var ObjectFunctionString = fnToString.call( Object );
105
106var support = {};
107
108var isFunction = function isFunction( obj ) {
109
110		// Support: Chrome <=57, Firefox <=52
111		// In some browsers, typeof returns "function" for HTML <object> elements
112		// (i.e., `typeof document.createElement( "object" ) === "function"`).
113		// We don't want to classify *any* DOM node as a function.
114		// Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5
115		// Plus for old WebKit, typeof returns "function" for HTML collections
116		// (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756)
117		return typeof obj === "function" && typeof obj.nodeType !== "number" &&
118			typeof obj.item !== "function";
119	};
120
121
122var isWindow = function isWindow( obj ) {
123		return obj != null && obj === obj.window;
124	};
125
126
127var document = window.document;
128
129
130
131	var preservedScriptAttributes = {
132		type: true,
133		src: true,
134		nonce: true,
135		noModule: true
136	};
137
138	function DOMEval( code, node, doc ) {
139		doc = doc || document;
140
141		var i, val,
142			script = doc.createElement( "script" );
143
144		script.text = code;
145		if ( node ) {
146			for ( i in preservedScriptAttributes ) {
147
148				// Support: Firefox 64+, Edge 18+
149				// Some browsers don't support the "nonce" property on scripts.
150				// On the other hand, just using `getAttribute` is not enough as
151				// the `nonce` attribute is reset to an empty string whenever it
152				// becomes browsing-context connected.
153				// See https://github.com/whatwg/html/issues/2369
154				// See https://html.spec.whatwg.org/#nonce-attributes
155				// The `node.getAttribute` check was added for the sake of
156				// `jQuery.globalEval` so that it can fake a nonce-containing node
157				// via an object.
158				val = node[ i ] || node.getAttribute && node.getAttribute( i );
159				if ( val ) {
160					script.setAttribute( i, val );
161				}
162			}
163		}
164		doc.head.appendChild( script ).parentNode.removeChild( script );
165	}
166
167
168function toType( obj ) {
169	if ( obj == null ) {
170		return obj + "";
171	}
172
173	// Support: Android <=2.3 only (functionish RegExp)
174	return typeof obj === "object" || typeof obj === "function" ?
175		class2type[ toString.call( obj ) ] || "object" :
176		typeof obj;
177}
178/* global Symbol */
179// Defining this global in .eslintrc.json would create a danger of using the global
180// unguarded in another place, it seems safer to define global only for this module
181
182
183
184var version = "3.7.0",
185
186	rhtmlSuffix = /HTML$/i,
187
188	// Define a local copy of jQuery
189	jQuery = function( selector, context ) {
190
191		// The jQuery object is actually just the init constructor 'enhanced'
192		// Need init if jQuery is called (just allow error to be thrown if not included)
193		return new jQuery.fn.init( selector, context );
194	};
195
196jQuery.fn = jQuery.prototype = {
197
198	// The current version of jQuery being used
199	jquery: version,
200
201	constructor: jQuery,
202
203	// The default length of a jQuery object is 0
204	length: 0,
205
206	toArray: function() {
207		return slice.call( this );
208	},
209
210	// Get the Nth element in the matched element set OR
211	// Get the whole matched element set as a clean array
212	get: function( num ) {
213
214		// Return all the elements in a clean array
215		if ( num == null ) {
216			return slice.call( this );
217		}
218
219		// Return just the one element from the set
220		return num < 0 ? this[ num + this.length ] : this[ num ];
221	},
222
223	// Take an array of elements and push it onto the stack
224	// (returning the new matched element set)
225	pushStack: function( elems ) {
226
227		// Build a new jQuery matched element set
228		var ret = jQuery.merge( this.constructor(), elems );
229
230		// Add the old object onto the stack (as a reference)
231		ret.prevObject = this;
232
233		// Return the newly-formed element set
234		return ret;
235	},
236
237	// Execute a callback for every element in the matched set.
238	each: function( callback ) {
239		return jQuery.each( this, callback );
240	},
241
242	map: function( callback ) {
243		return this.pushStack( jQuery.map( this, function( elem, i ) {
244			return callback.call( elem, i, elem );
245		} ) );
246	},
247
248	slice: function() {
249		return this.pushStack( slice.apply( this, arguments ) );
250	},
251
252	first: function() {
253		return this.eq( 0 );
254	},
255
256	last: function() {
257		return this.eq( -1 );
258	},
259
260	even: function() {
261		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
262			return ( i + 1 ) % 2;
263		} ) );
264	},
265
266	odd: function() {
267		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
268			return i % 2;
269		} ) );
270	},
271
272	eq: function( i ) {
273		var len = this.length,
274			j = +i + ( i < 0 ? len : 0 );
275		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
276	},
277
278	end: function() {
279		return this.prevObject || this.constructor();
280	},
281
282	// For internal use only.
283	// Behaves like an Array's method, not like a jQuery method.
284	push: push,
285	sort: arr.sort,
286	splice: arr.splice
287};
288
289jQuery.extend = jQuery.fn.extend = function() {
290	var options, name, src, copy, copyIsArray, clone,
291		target = arguments[ 0 ] || {},
292		i = 1,
293		length = arguments.length,
294		deep = false;
295
296	// Handle a deep copy situation
297	if ( typeof target === "boolean" ) {
298		deep = target;
299
300		// Skip the boolean and the target
301		target = arguments[ i ] || {};
302		i++;
303	}
304
305	// Handle case when target is a string or something (possible in deep copy)
306	if ( typeof target !== "object" && !isFunction( target ) ) {
307		target = {};
308	}
309
310	// Extend jQuery itself if only one argument is passed
311	if ( i === length ) {
312		target = this;
313		i--;
314	}
315
316	for ( ; i < length; i++ ) {
317
318		// Only deal with non-null/undefined values
319		if ( ( options = arguments[ i ] ) != null ) {
320
321			// Extend the base object
322			for ( name in options ) {
323				copy = options[ name ];
324
325				// Prevent Object.prototype pollution
326				// Prevent never-ending loop
327				if ( name === "__proto__" || target === copy ) {
328					continue;
329				}
330
331				// Recurse if we're merging plain objects or arrays
332				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
333					( copyIsArray = Array.isArray( copy ) ) ) ) {
334					src = target[ name ];
335
336					// Ensure proper type for the source value
337					if ( copyIsArray && !Array.isArray( src ) ) {
338						clone = [];
339					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
340						clone = {};
341					} else {
342						clone = src;
343					}
344					copyIsArray = false;
345
346					// Never move original objects, clone them
347					target[ name ] = jQuery.extend( deep, clone, copy );
348
349				// Don't bring in undefined values
350				} else if ( copy !== undefined ) {
351					target[ name ] = copy;
352				}
353			}
354		}
355	}
356
357	// Return the modified object
358	return target;
359};
360
361jQuery.extend( {
362
363	// Unique for each copy of jQuery on the page
364	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
365
366	// Assume jQuery is ready without the ready module
367	isReady: true,
368
369	error: function( msg ) {
370		throw new Error( msg );
371	},
372
373	noop: function() {},
374
375	isPlainObject: function( obj ) {
376		var proto, Ctor;
377
378		// Detect obvious negatives
379		// Use toString instead of jQuery.type to catch host objects
380		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
381			return false;
382		}
383
384		proto = getProto( obj );
385
386		// Objects with no prototype (e.g., `Object.create( null )`) are plain
387		if ( !proto ) {
388			return true;
389		}
390
391		// Objects with prototype are plain iff they were constructed by a global Object function
392		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
393		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
394	},
395
396	isEmptyObject: function( obj ) {
397		var name;
398
399		for ( name in obj ) {
400			return false;
401		}
402		return true;
403	},
404
405	// Evaluates a script in a provided context; falls back to the global one
406	// if not specified.
407	globalEval: function( code, options, doc ) {
408		DOMEval( code, { nonce: options && options.nonce }, doc );
409	},
410
411	each: function( obj, callback ) {
412		var length, i = 0;
413
414		if ( isArrayLike( obj ) ) {
415			length = obj.length;
416			for ( ; i < length; i++ ) {
417				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
418					break;
419				}
420			}
421		} else {
422			for ( i in obj ) {
423				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
424					break;
425				}
426			}
427		}
428
429		return obj;
430	},
431
432
433	// Retrieve the text value of an array of DOM nodes
434	text: function( elem ) {
435		var node,
436			ret = "",
437			i = 0,
438			nodeType = elem.nodeType;
439
440		if ( !nodeType ) {
441
442			// If no nodeType, this is expected to be an array
443			while ( ( node = elem[ i++ ] ) ) {
444
445				// Do not traverse comment nodes
446				ret += jQuery.text( node );
447			}
448		} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
449			return elem.textContent;
450		} else if ( nodeType === 3 || nodeType === 4 ) {
451			return elem.nodeValue;
452		}
453
454		// Do not include comment or processing instruction nodes
455
456		return ret;
457	},
458
459	// results is for internal usage only
460	makeArray: function( arr, results ) {
461		var ret = results || [];
462
463		if ( arr != null ) {
464			if ( isArrayLike( Object( arr ) ) ) {
465				jQuery.merge( ret,
466					typeof arr === "string" ?
467						[ arr ] : arr
468				);
469			} else {
470				push.call( ret, arr );
471			}
472		}
473
474		return ret;
475	},
476
477	inArray: function( elem, arr, i ) {
478		return arr == null ? -1 : indexOf.call( arr, elem, i );
479	},
480
481	isXMLDoc: function( elem ) {
482		var namespace = elem && elem.namespaceURI,
483			docElem = elem && ( elem.ownerDocument || elem ).documentElement;
484
485		// Assume HTML when documentElement doesn't yet exist, such as inside
486		// document fragments.
487		return !rhtmlSuffix.test( namespace || docElem && docElem.nodeName || "HTML" );
488	},
489
490	// Support: Android <=4.0 only, PhantomJS 1 only
491	// push.apply(_, arraylike) throws on ancient WebKit
492	merge: function( first, second ) {
493		var len = +second.length,
494			j = 0,
495			i = first.length;
496
497		for ( ; j < len; j++ ) {
498			first[ i++ ] = second[ j ];
499		}
500
501		first.length = i;
502
503		return first;
504	},
505
506	grep: function( elems, callback, invert ) {
507		var callbackInverse,
508			matches = [],
509			i = 0,
510			length = elems.length,
511			callbackExpect = !invert;
512
513		// Go through the array, only saving the items
514		// that pass the validator function
515		for ( ; i < length; i++ ) {
516			callbackInverse = !callback( elems[ i ], i );
517			if ( callbackInverse !== callbackExpect ) {
518				matches.push( elems[ i ] );
519			}
520		}
521
522		return matches;
523	},
524
525	// arg is for internal usage only
526	map: function( elems, callback, arg ) {
527		var length, value,
528			i = 0,
529			ret = [];
530
531		// Go through the array, translating each of the items to their new values
532		if ( isArrayLike( elems ) ) {
533			length = elems.length;
534			for ( ; i < length; i++ ) {
535				value = callback( elems[ i ], i, arg );
536
537				if ( value != null ) {
538					ret.push( value );
539				}
540			}
541
542		// Go through every key on the object,
543		} else {
544			for ( i in elems ) {
545				value = callback( elems[ i ], i, arg );
546
547				if ( value != null ) {
548					ret.push( value );
549				}
550			}
551		}
552
553		// Flatten any nested arrays
554		return flat( ret );
555	},
556
557	// A global GUID counter for objects
558	guid: 1,
559
560	// jQuery.support is not used in Core but other projects attach their
561	// properties to it so it needs to exist.
562	support: support
563} );
564
565if ( typeof Symbol === "function" ) {
566	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
567}
568
569// Populate the class2type map
570jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
571	function( _i, name ) {
572		class2type[ "[object " + name + "]" ] = name.toLowerCase();
573	} );
574
575function isArrayLike( obj ) {
576
577	// Support: real iOS 8.2 only (not reproducible in simulator)
578	// `in` check used to prevent JIT error (gh-2145)
579	// hasOwn isn't used here due to false negatives
580	// regarding Nodelist length in IE
581	var length = !!obj && "length" in obj && obj.length,
582		type = toType( obj );
583
584	if ( isFunction( obj ) || isWindow( obj ) ) {
585		return false;
586	}
587
588	return type === "array" || length === 0 ||
589		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
590}
591
592
593function nodeName( elem, name ) {
594
595	return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
596
597}
598var pop = arr.pop;
599
600
601var sort = arr.sort;
602
603
604var splice = arr.splice;
605
606
607var whitespace = "[\\x20\\t\\r\\n\\f]";
608
609
610var rtrimCSS = new RegExp(
611	"^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$",
612	"g"
613);
614
615
616
617
618// Note: an element does not contain itself
619jQuery.contains = function( a, b ) {
620	var bup = b && b.parentNode;
621
622	return a === bup || !!( bup && bup.nodeType === 1 && (
623
624		// Support: IE 9 - 11+
625		// IE doesn't have `contains` on SVG.
626		a.contains ?
627			a.contains( bup ) :
628			a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
629	) );
630};
631
632
633
634
635// CSS string/identifier serialization
636// https://drafts.csswg.org/cssom/#common-serializing-idioms
637var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g;
638
639function fcssescape( ch, asCodePoint ) {
640	if ( asCodePoint ) {
641
642		// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
643		if ( ch === "\0" ) {
644			return "\uFFFD";
645		}
646
647		// Control characters and (dependent upon position) numbers get escaped as code points
648		return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
649	}
650
651	// Other potentially-special ASCII characters get backslash-escaped
652	return "\\" + ch;
653}
654
655jQuery.escapeSelector = function( sel ) {
656	return ( sel + "" ).replace( rcssescape, fcssescape );
657};
658
659
660
661
662var preferredDoc = document,
663	pushNative = push;
664
665( function() {
666
667var i,
668	Expr,
669	outermostContext,
670	sortInput,
671	hasDuplicate,
672	push = pushNative,
673
674	// Local document vars
675	document,
676	documentElement,
677	documentIsHTML,
678	rbuggyQSA,
679	matches,
680
681	// Instance-specific data
682	expando = jQuery.expando,
683	dirruns = 0,
684	done = 0,
685	classCache = createCache(),
686	tokenCache = createCache(),
687	compilerCache = createCache(),
688	nonnativeSelectorCache = createCache(),
689	sortOrder = function( a, b ) {
690		if ( a === b ) {
691			hasDuplicate = true;
692		}
693		return 0;
694	},
695
696	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|" +
697		"loop|multiple|open|readonly|required|scoped",
698
699	// Regular expressions
700
701	// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
702	identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
703		"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
704
705	// Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors
706	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
707
708		// Operator (capture 2)
709		"*([*^$|!~]?=)" + whitespace +
710
711		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
712		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
713		whitespace + "*\\]",
714
715	pseudos = ":(" + identifier + ")(?:\\((" +
716
717		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
718		// 1. quoted (capture 3; capture 4 or capture 5)
719		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
720
721		// 2. simple (capture 6)
722		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
723
724		// 3. anything else (capture 2)
725		".*" +
726		")\\)|)",
727
728	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
729	rwhitespace = new RegExp( whitespace + "+", "g" ),
730
731	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
732	rleadingCombinator = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" +
733		whitespace + "*" ),
734	rdescend = new RegExp( whitespace + "|>" ),
735
736	rpseudo = new RegExp( pseudos ),
737	ridentifier = new RegExp( "^" + identifier + "$" ),
738
739	matchExpr = {
740		ID: new RegExp( "^#(" + identifier + ")" ),
741		CLASS: new RegExp( "^\\.(" + identifier + ")" ),
742		TAG: new RegExp( "^(" + identifier + "|[*])" ),
743		ATTR: new RegExp( "^" + attributes ),
744		PSEUDO: new RegExp( "^" + pseudos ),
745		CHILD: new RegExp(
746			"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
747				whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
748				whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
749		bool: new RegExp( "^(?:" + booleans + ")$", "i" ),
750
751		// For use in libraries implementing .is()
752		// We use this for POS matching in `select`
753		needsContext: new RegExp( "^" + whitespace +
754			"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
755			"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
756	},
757
758	rinputs = /^(?:input|select|textarea|button)$/i,
759	rheader = /^h\d$/i,
760
761	// Easily-parseable/retrievable ID or TAG or CLASS selectors
762	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
763
764	rsibling = /[+~]/,
765
766	// CSS escapes
767	// https://www.w3.org/TR/CSS21/syndata.html#escaped-characters
768	runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace +
769		"?|\\\\([^\\r\\n\\f])", "g" ),
770	funescape = function( escape, nonHex ) {
771		var high = "0x" + escape.slice( 1 ) - 0x10000;
772
773		if ( nonHex ) {
774
775			// Strip the backslash prefix from a non-hex escape sequence
776			return nonHex;
777		}
778
779		// Replace a hexadecimal escape sequence with the encoded Unicode code point
780		// Support: IE <=11+
781		// For values outside the Basic Multilingual Plane (BMP), manually construct a
782		// surrogate pair
783		return high < 0 ?
784			String.fromCharCode( high + 0x10000 ) :
785			String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
786	},
787
788	// Used for iframes; see `setDocument`.
789	// Support: IE 9 - 11+, Edge 12 - 18+
790	// Removing the function wrapper causes a "Permission Denied"
791	// error in IE/Edge.
792	unloadHandler = function() {
793		setDocument();
794	},
795
796	inDisabledFieldset = addCombinator(
797		function( elem ) {
798			return elem.disabled === true && nodeName( elem, "fieldset" );
799		},
800		{ dir: "parentNode", next: "legend" }
801	);
802
803// Support: IE <=9 only
804// Accessing document.activeElement can throw unexpectedly
805// https://bugs.jquery.com/ticket/13393
806function safeActiveElement() {
807	try {
808		return document.activeElement;
809	} catch ( err ) { }
810}
811
812// Optimize for push.apply( _, NodeList )
813try {
814	push.apply(
815		( arr = slice.call( preferredDoc.childNodes ) ),
816		preferredDoc.childNodes
817	);
818
819	// Support: Android <=4.0
820	// Detect silently failing push.apply
821	// eslint-disable-next-line no-unused-expressions
822	arr[ preferredDoc.childNodes.length ].nodeType;
823} catch ( e ) {
824	push = {
825		apply: function( target, els ) {
826			pushNative.apply( target, slice.call( els ) );
827		},
828		call: function( target ) {
829			pushNative.apply( target, slice.call( arguments, 1 ) );
830		}
831	};
832}
833
834function find( selector, context, results, seed ) {
835	var m, i, elem, nid, match, groups, newSelector,
836		newContext = context && context.ownerDocument,
837
838		// nodeType defaults to 9, since context defaults to document
839		nodeType = context ? context.nodeType : 9;
840
841	results = results || [];
842
843	// Return early from calls with invalid selector or context
844	if ( typeof selector !== "string" || !selector ||
845		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
846
847		return results;
848	}
849
850	// Try to shortcut find operations (as opposed to filters) in HTML documents
851	if ( !seed ) {
852		setDocument( context );
853		context = context || document;
854
855		if ( documentIsHTML ) {
856
857			// If the selector is sufficiently simple, try using a "get*By*" DOM method
858			// (excepting DocumentFragment context, where the methods don't exist)
859			if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
860
861				// ID selector
862				if ( ( m = match[ 1 ] ) ) {
863
864					// Document context
865					if ( nodeType === 9 ) {
866						if ( ( elem = context.getElementById( m ) ) ) {
867
868							// Support: IE 9 only
869							// getElementById can match elements by name instead of ID
870							if ( elem.id === m ) {
871								push.call( results, elem );
872								return results;
873							}
874						} else {
875							return results;
876						}
877
878					// Element context
879					} else {
880
881						// Support: IE 9 only
882						// getElementById can match elements by name instead of ID
883						if ( newContext && ( elem = newContext.getElementById( m ) ) &&
884							find.contains( context, elem ) &&
885							elem.id === m ) {
886
887							push.call( results, elem );
888							return results;
889						}
890					}
891
892				// Type selector
893				} else if ( match[ 2 ] ) {
894					push.apply( results, context.getElementsByTagName( selector ) );
895					return results;
896
897				// Class selector
898				} else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) {
899					push.apply( results, context.getElementsByClassName( m ) );
900					return results;
901				}
902			}
903
904			// Take advantage of querySelectorAll
905			if ( !nonnativeSelectorCache[ selector + " " ] &&
906				( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) {
907
908				newSelector = selector;
909				newContext = context;
910
911				// qSA considers elements outside a scoping root when evaluating child or
912				// descendant combinators, which is not what we want.
913				// In such cases, we work around the behavior by prefixing every selector in the
914				// list with an ID selector referencing the scope context.
915				// The technique has to be used as well when a leading combinator is used
916				// as such selectors are not recognized by querySelectorAll.
917				// Thanks to Andrew Dupont for this technique.
918				if ( nodeType === 1 &&
919					( rdescend.test( selector ) || rleadingCombinator.test( selector ) ) ) {
920
921					// Expand context for sibling selectors
922					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
923						context;
924
925					// We can use :scope instead of the ID hack if the browser
926					// supports it & if we're not changing the context.
927					// Support: IE 11+, Edge 17 - 18+
928					// IE/Edge sometimes throw a "Permission denied" error when
929					// strict-comparing two documents; shallow comparisons work.
930					// eslint-disable-next-line eqeqeq
931					if ( newContext != context || !support.scope ) {
932
933						// Capture the context ID, setting it first if necessary
934						if ( ( nid = context.getAttribute( "id" ) ) ) {
935							nid = jQuery.escapeSelector( nid );
936						} else {
937							context.setAttribute( "id", ( nid = expando ) );
938						}
939					}
940
941					// Prefix every selector in the list
942					groups = tokenize( selector );
943					i = groups.length;
944					while ( i-- ) {
945						groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
946							toSelector( groups[ i ] );
947					}
948					newSelector = groups.join( "," );
949				}
950
951				try {
952					push.apply( results,
953						newContext.querySelectorAll( newSelector )
954					);
955					return results;
956				} catch ( qsaError ) {
957					nonnativeSelectorCache( selector, true );
958				} finally {
959					if ( nid === expando ) {
960						context.removeAttribute( "id" );
961					}
962				}
963			}
964		}
965	}
966
967	// All others
968	return select( selector.replace( rtrimCSS, "$1" ), context, results, seed );
969}
970
971/**
972 * Create key-value caches of limited size
973 * @returns {function(string, object)} Returns the Object data after storing it on itself with
974 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
975 *	deleting the oldest entry
976 */
977function createCache() {
978	var keys = [];
979
980	function cache( key, value ) {
981
982		// Use (key + " ") to avoid collision with native prototype properties
983		// (see https://github.com/jquery/sizzle/issues/157)
984		if ( keys.push( key + " " ) > Expr.cacheLength ) {
985
986			// Only keep the most recent entries
987			delete cache[ keys.shift() ];
988		}
989		return ( cache[ key + " " ] = value );
990	}
991	return cache;
992}
993
994/**
995 * Mark a function for special use by jQuery selector module
996 * @param {Function} fn The function to mark
997 */
998function markFunction( fn ) {
999	fn[ expando ] = true;
1000	return fn;
1001}
1002
1003/**
1004 * Support testing using an element
1005 * @param {Function} fn Passed the created element and returns a boolean result
1006 */
1007function assert( fn ) {
1008	var el = document.createElement( "fieldset" );
1009
1010	try {
1011		return !!fn( el );
1012	} catch ( e ) {
1013		return false;
1014	} finally {
1015
1016		// Remove from its parent by default
1017		if ( el.parentNode ) {
1018			el.parentNode.removeChild( el );
1019		}
1020
1021		// release memory in IE
1022		el = null;
1023	}
1024}
1025
1026/**
1027 * Returns a function to use in pseudos for input types
1028 * @param {String} type
1029 */
1030function createInputPseudo( type ) {
1031	return function( elem ) {
1032		return nodeName( elem, "input" ) && elem.type === type;
1033	};
1034}
1035
1036/**
1037 * Returns a function to use in pseudos for buttons
1038 * @param {String} type
1039 */
1040function createButtonPseudo( type ) {
1041	return function( elem ) {
1042		return ( nodeName( elem, "input" ) || nodeName( elem, "button" ) ) &&
1043			elem.type === type;
1044	};
1045}
1046
1047/**
1048 * Returns a function to use in pseudos for :enabled/:disabled
1049 * @param {Boolean} disabled true for :disabled; false for :enabled
1050 */
1051function createDisabledPseudo( disabled ) {
1052
1053	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1054	return function( elem ) {
1055
1056		// Only certain elements can match :enabled or :disabled
1057		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1058		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1059		if ( "form" in elem ) {
1060
1061			// Check for inherited disabledness on relevant non-disabled elements:
1062			// * listed form-associated elements in a disabled fieldset
1063			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
1064			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1065			// * option elements in a disabled optgroup
1066			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1067			// All such elements have a "form" property.
1068			if ( elem.parentNode && elem.disabled === false ) {
1069
1070				// Option elements defer to a parent optgroup if present
1071				if ( "label" in elem ) {
1072					if ( "label" in elem.parentNode ) {
1073						return elem.parentNode.disabled === disabled;
1074					} else {
1075						return elem.disabled === disabled;
1076					}
1077				}
1078
1079				// Support: IE 6 - 11+
1080				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
1081				return elem.isDisabled === disabled ||
1082
1083					// Where there is no isDisabled, check manually
1084					elem.isDisabled !== !disabled &&
1085						inDisabledFieldset( elem ) === disabled;
1086			}
1087
1088			return elem.disabled === disabled;
1089
1090		// Try to winnow out elements that can't be disabled before trusting the disabled property.
1091		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1092		// even exist on them, let alone have a boolean value.
1093		} else if ( "label" in elem ) {
1094			return elem.disabled === disabled;
1095		}
1096
1097		// Remaining elements are neither :enabled nor :disabled
1098		return false;
1099	};
1100}
1101
1102/**
1103 * Returns a function to use in pseudos for positionals
1104 * @param {Function} fn
1105 */
1106function createPositionalPseudo( fn ) {
1107	return markFunction( function( argument ) {
1108		argument = +argument;
1109		return markFunction( function( seed, matches ) {
1110			var j,
1111				matchIndexes = fn( [], seed.length, argument ),
1112				i = matchIndexes.length;
1113
1114			// Match elements found at the specified indexes
1115			while ( i-- ) {
1116				if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
1117					seed[ j ] = !( matches[ j ] = seed[ j ] );
1118				}
1119			}
1120		} );
1121	} );
1122}
1123
1124/**
1125 * Checks a node for validity as a jQuery selector context
1126 * @param {Element|Object=} context
1127 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1128 */
1129function testContext( context ) {
1130	return context && typeof context.getElementsByTagName !== "undefined" && context;
1131}
1132
1133/**
1134 * Sets document-related variables once based on the current document
1135 * @param {Element|Object} [node] An element or document object to use to set the document
1136 * @returns {Object} Returns the current document
1137 */
1138function setDocument( node ) {
1139	var subWindow,
1140		doc = node ? node.ownerDocument || node : preferredDoc;
1141
1142	// Return early if doc is invalid or already selected
1143	// Support: IE 11+, Edge 17 - 18+
1144	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1145	// two documents; shallow comparisons work.
1146	// eslint-disable-next-line eqeqeq
1147	if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
1148		return document;
1149	}
1150
1151	// Update global variables
1152	document = doc;
1153	documentElement = document.documentElement;
1154	documentIsHTML = !jQuery.isXMLDoc( document );
1155
1156	// Support: iOS 7 only, IE 9 - 11+
1157	// Older browsers didn't support unprefixed `matches`.
1158	matches = documentElement.matches ||
1159		documentElement.webkitMatchesSelector ||
1160		documentElement.msMatchesSelector;
1161
1162	// Support: IE 9 - 11+, Edge 12 - 18+
1163	// Accessing iframe documents after unload throws "permission denied" errors (see trac-13936)
1164	// Support: IE 11+, Edge 17 - 18+
1165	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1166	// two documents; shallow comparisons work.
1167	// eslint-disable-next-line eqeqeq
1168	if ( preferredDoc != document &&
1169		( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
1170
1171		// Support: IE 9 - 11+, Edge 12 - 18+
1172		subWindow.addEventListener( "unload", unloadHandler );
1173	}
1174
1175	// Support: IE <10
1176	// Check if getElementById returns elements by name
1177	// The broken getElementById methods don't pick up programmatically-set names,
1178	// so use a roundabout getElementsByName test
1179	support.getById = assert( function( el ) {
1180		documentElement.appendChild( el ).id = jQuery.expando;
1181		return !document.getElementsByName ||
1182			!document.getElementsByName( jQuery.expando ).length;
1183	} );
1184
1185	// Support: IE 9 only
1186	// Check to see if it's possible to do matchesSelector
1187	// on a disconnected node.
1188	support.disconnectedMatch = assert( function( el ) {
1189		return matches.call( el, "*" );
1190	} );
1191
1192	// Support: IE 9 - 11+, Edge 12 - 18+
1193	// IE/Edge don't support the :scope pseudo-class.
1194	support.scope = assert( function() {
1195		return document.querySelectorAll( ":scope" );
1196	} );
1197
1198	// Support: Chrome 105 - 111 only, Safari 15.4 - 16.3 only
1199	// Make sure the `:has()` argument is parsed unforgivingly.
1200	// We include `*` in the test to detect buggy implementations that are
1201	// _selectively_ forgiving (specifically when the list includes at least
1202	// one valid selector).
1203	// Note that we treat complete lack of support for `:has()` as if it were
1204	// spec-compliant support, which is fine because use of `:has()` in such
1205	// environments will fail in the qSA path and fall back to jQuery traversal
1206	// anyway.
1207	support.cssHas = assert( function() {
1208		try {
1209			document.querySelector( ":has(*,:jqfake)" );
1210			return false;
1211		} catch ( e ) {
1212			return true;
1213		}
1214	} );
1215
1216	// ID filter and find
1217	if ( support.getById ) {
1218		Expr.filter.ID = function( id ) {
1219			var attrId = id.replace( runescape, funescape );
1220			return function( elem ) {
1221				return elem.getAttribute( "id" ) === attrId;
1222			};
1223		};
1224		Expr.find.ID = function( id, context ) {
1225			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1226				var elem = context.getElementById( id );
1227				return elem ? [ elem ] : [];
1228			}
1229		};
1230	} else {
1231		Expr.filter.ID =  function( id ) {
1232			var attrId = id.replace( runescape, funescape );
1233			return function( elem ) {
1234				var node = typeof elem.getAttributeNode !== "undefined" &&
1235					elem.getAttributeNode( "id" );
1236				return node && node.value === attrId;
1237			};
1238		};
1239
1240		// Support: IE 6 - 7 only
1241		// getElementById is not reliable as a find shortcut
1242		Expr.find.ID = function( id, context ) {
1243			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1244				var node, i, elems,
1245					elem = context.getElementById( id );
1246
1247				if ( elem ) {
1248
1249					// Verify the id attribute
1250					node = elem.getAttributeNode( "id" );
1251					if ( node && node.value === id ) {
1252						return [ elem ];
1253					}
1254
1255					// Fall back on getElementsByName
1256					elems = context.getElementsByName( id );
1257					i = 0;
1258					while ( ( elem = elems[ i++ ] ) ) {
1259						node = elem.getAttributeNode( "id" );
1260						if ( node && node.value === id ) {
1261							return [ elem ];
1262						}
1263					}
1264				}
1265
1266				return [];
1267			}
1268		};
1269	}
1270
1271	// Tag
1272	Expr.find.TAG = function( tag, context ) {
1273		if ( typeof context.getElementsByTagName !== "undefined" ) {
1274			return context.getElementsByTagName( tag );
1275
1276		// DocumentFragment nodes don't have gEBTN
1277		} else {
1278			return context.querySelectorAll( tag );
1279		}
1280	};
1281
1282	// Class
1283	Expr.find.CLASS = function( className, context ) {
1284		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1285			return context.getElementsByClassName( className );
1286		}
1287	};
1288
1289	/* QSA/matchesSelector
1290	---------------------------------------------------------------------- */
1291
1292	// QSA and matchesSelector support
1293
1294	rbuggyQSA = [];
1295
1296	// Build QSA regex
1297	// Regex strategy adopted from Diego Perini
1298	assert( function( el ) {
1299
1300		var input;
1301
1302		documentElement.appendChild( el ).innerHTML =
1303			"<a id='" + expando + "' href='' disabled='disabled'></a>" +
1304			"<select id='" + expando + "-\r\\' disabled='disabled'>" +
1305			"<option selected=''></option></select>";
1306
1307		// Support: iOS <=7 - 8 only
1308		// Boolean attributes and "value" are not treated correctly in some XML documents
1309		if ( !el.querySelectorAll( "[selected]" ).length ) {
1310			rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1311		}
1312
1313		// Support: iOS <=7 - 8 only
1314		if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1315			rbuggyQSA.push( "~=" );
1316		}
1317
1318		// Support: iOS 8 only
1319		// https://bugs.webkit.org/show_bug.cgi?id=136851
1320		// In-page `selector#id sibling-combinator selector` fails
1321		if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
1322			rbuggyQSA.push( ".#.+[+~]" );
1323		}
1324
1325		// Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+
1326		// In some of the document kinds, these selectors wouldn't work natively.
1327		// This is probably OK but for backwards compatibility we want to maintain
1328		// handling them through jQuery traversal in jQuery 3.x.
1329		if ( !el.querySelectorAll( ":checked" ).length ) {
1330			rbuggyQSA.push( ":checked" );
1331		}
1332
1333		// Support: Windows 8 Native Apps
1334		// The type and name attributes are restricted during .innerHTML assignment
1335		input = document.createElement( "input" );
1336		input.setAttribute( "type", "hidden" );
1337		el.appendChild( input ).setAttribute( "name", "D" );
1338
1339		// Support: IE 9 - 11+
1340		// IE's :disabled selector does not pick up the children of disabled fieldsets
1341		// Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+
1342		// In some of the document kinds, these selectors wouldn't work natively.
1343		// This is probably OK but for backwards compatibility we want to maintain
1344		// handling them through jQuery traversal in jQuery 3.x.
1345		documentElement.appendChild( el ).disabled = true;
1346		if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
1347			rbuggyQSA.push( ":enabled", ":disabled" );
1348		}
1349
1350		// Support: IE 11+, Edge 15 - 18+
1351		// IE 11/Edge don't find elements on a `[name='']` query in some cases.
1352		// Adding a temporary attribute to the document before the selection works
1353		// around the issue.
1354		// Interestingly, IE 10 & older don't seem to have the issue.
1355		input = document.createElement( "input" );
1356		input.setAttribute( "name", "" );
1357		el.appendChild( input );
1358		if ( !el.querySelectorAll( "[name='']" ).length ) {
1359			rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
1360				whitespace + "*(?:''|\"\")" );
1361		}
1362	} );
1363
1364	if ( !support.cssHas ) {
1365
1366		// Support: Chrome 105 - 110+, Safari 15.4 - 16.3+
1367		// Our regular `try-catch` mechanism fails to detect natively-unsupported
1368		// pseudo-classes inside `:has()` (such as `:has(:contains("Foo"))`)
1369		// in browsers that parse the `:has()` argument as a forgiving selector list.
1370		// https://drafts.csswg.org/selectors/#relational now requires the argument
1371		// to be parsed unforgivingly, but browsers have not yet fully adjusted.
1372		rbuggyQSA.push( ":has" );
1373	}
1374
1375	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
1376
1377	/* Sorting
1378	---------------------------------------------------------------------- */
1379
1380	// Document order sorting
1381	sortOrder = function( a, b ) {
1382
1383		// Flag for duplicate removal
1384		if ( a === b ) {
1385			hasDuplicate = true;
1386			return 0;
1387		}
1388
1389		// Sort on method existence if only one input has compareDocumentPosition
1390		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1391		if ( compare ) {
1392			return compare;
1393		}
1394
1395		// Calculate position if both inputs belong to the same document
1396		// Support: IE 11+, Edge 17 - 18+
1397		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1398		// two documents; shallow comparisons work.
1399		// eslint-disable-next-line eqeqeq
1400		compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
1401			a.compareDocumentPosition( b ) :
1402
1403			// Otherwise we know they are disconnected
1404			1;
1405
1406		// Disconnected nodes
1407		if ( compare & 1 ||
1408			( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {
1409
1410			// Choose the first element that is related to our preferred document
1411			// Support: IE 11+, Edge 17 - 18+
1412			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1413			// two documents; shallow comparisons work.
1414			// eslint-disable-next-line eqeqeq
1415			if ( a === document || a.ownerDocument == preferredDoc &&
1416				find.contains( preferredDoc, a ) ) {
1417				return -1;
1418			}
1419
1420			// Support: IE 11+, Edge 17 - 18+
1421			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1422			// two documents; shallow comparisons work.
1423			// eslint-disable-next-line eqeqeq
1424			if ( b === document || b.ownerDocument == preferredDoc &&
1425				find.contains( preferredDoc, b ) ) {
1426				return 1;
1427			}
1428
1429			// Maintain original order
1430			return sortInput ?
1431				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1432				0;
1433		}
1434
1435		return compare & 4 ? -1 : 1;
1436	};
1437
1438	return document;
1439}
1440
1441find.matches = function( expr, elements ) {
1442	return find( expr, null, null, elements );
1443};
1444
1445find.matchesSelector = function( elem, expr ) {
1446	setDocument( elem );
1447
1448	if ( documentIsHTML &&
1449		!nonnativeSelectorCache[ expr + " " ] &&
1450		( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {
1451
1452		try {
1453			var ret = matches.call( elem, expr );
1454
1455			// IE 9's matchesSelector returns false on disconnected nodes
1456			if ( ret || support.disconnectedMatch ||
1457
1458					// As well, disconnected nodes are said to be in a document
1459					// fragment in IE 9
1460					elem.document && elem.document.nodeType !== 11 ) {
1461				return ret;
1462			}
1463		} catch ( e ) {
1464			nonnativeSelectorCache( expr, true );
1465		}
1466	}
1467
1468	return find( expr, document, null, [ elem ] ).length > 0;
1469};
1470
1471find.contains = function( context, elem ) {
1472
1473	// Set document vars if needed
1474	// Support: IE 11+, Edge 17 - 18+
1475	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1476	// two documents; shallow comparisons work.
1477	// eslint-disable-next-line eqeqeq
1478	if ( ( context.ownerDocument || context ) != document ) {
1479		setDocument( context );
1480	}
1481	return jQuery.contains( context, elem );
1482};
1483
1484
1485find.attr = function( elem, name ) {
1486
1487	// Set document vars if needed
1488	// Support: IE 11+, Edge 17 - 18+
1489	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1490	// two documents; shallow comparisons work.
1491	// eslint-disable-next-line eqeqeq
1492	if ( ( elem.ownerDocument || elem ) != document ) {
1493		setDocument( elem );
1494	}
1495
1496	var fn = Expr.attrHandle[ name.toLowerCase() ],
1497
1498		// Don't get fooled by Object.prototype properties (see trac-13807)
1499		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1500			fn( elem, name, !documentIsHTML ) :
1501			undefined;
1502
1503	if ( val !== undefined ) {
1504		return val;
1505	}
1506
1507	return elem.getAttribute( name );
1508};
1509
1510find.error = function( msg ) {
1511	throw new Error( "Syntax error, unrecognized expression: " + msg );
1512};
1513
1514/**
1515 * Document sorting and removing duplicates
1516 * @param {ArrayLike} results
1517 */
1518jQuery.uniqueSort = function( results ) {
1519	var elem,
1520		duplicates = [],
1521		j = 0,
1522		i = 0;
1523
1524	// Unless we *know* we can detect duplicates, assume their presence
1525	//
1526	// Support: Android <=4.0+
1527	// Testing for detecting duplicates is unpredictable so instead assume we can't
1528	// depend on duplicate detection in all browsers without a stable sort.
1529	hasDuplicate = !support.sortStable;
1530	sortInput = !support.sortStable && slice.call( results, 0 );
1531	sort.call( results, sortOrder );
1532
1533	if ( hasDuplicate ) {
1534		while ( ( elem = results[ i++ ] ) ) {
1535			if ( elem === results[ i ] ) {
1536				j = duplicates.push( i );
1537			}
1538		}
1539		while ( j-- ) {
1540			splice.call( results, duplicates[ j ], 1 );
1541		}
1542	}
1543
1544	// Clear input after sorting to release objects
1545	// See https://github.com/jquery/sizzle/pull/225
1546	sortInput = null;
1547
1548	return results;
1549};
1550
1551jQuery.fn.uniqueSort = function() {
1552	return this.pushStack( jQuery.uniqueSort( slice.apply( this ) ) );
1553};
1554
1555Expr = jQuery.expr = {
1556
1557	// Can be adjusted by the user
1558	cacheLength: 50,
1559
1560	createPseudo: markFunction,
1561
1562	match: matchExpr,
1563
1564	attrHandle: {},
1565
1566	find: {},
1567
1568	relative: {
1569		">": { dir: "parentNode", first: true },
1570		" ": { dir: "parentNode" },
1571		"+": { dir: "previousSibling", first: true },
1572		"~": { dir: "previousSibling" }
1573	},
1574
1575	preFilter: {
1576		ATTR: function( match ) {
1577			match[ 1 ] = match[ 1 ].replace( runescape, funescape );
1578
1579			// Move the given value to match[3] whether quoted or unquoted
1580			match[ 3 ] = ( match[ 3 ] || match[ 4 ] || match[ 5 ] || "" )
1581				.replace( runescape, funescape );
1582
1583			if ( match[ 2 ] === "~=" ) {
1584				match[ 3 ] = " " + match[ 3 ] + " ";
1585			}
1586
1587			return match.slice( 0, 4 );
1588		},
1589
1590		CHILD: function( match ) {
1591
1592			/* matches from matchExpr["CHILD"]
1593				1 type (only|nth|...)
1594				2 what (child|of-type)
1595				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1596				4 xn-component of xn+y argument ([+-]?\d*n|)
1597				5 sign of xn-component
1598				6 x of xn-component
1599				7 sign of y-component
1600				8 y of y-component
1601			*/
1602			match[ 1 ] = match[ 1 ].toLowerCase();
1603
1604			if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
1605
1606				// nth-* requires argument
1607				if ( !match[ 3 ] ) {
1608					find.error( match[ 0 ] );
1609				}
1610
1611				// numeric x and y parameters for Expr.filter.CHILD
1612				// remember that false/true cast respectively to 0/1
1613				match[ 4 ] = +( match[ 4 ] ?
1614					match[ 5 ] + ( match[ 6 ] || 1 ) :
1615					2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" )
1616				);
1617				match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
1618
1619			// other types prohibit arguments
1620			} else if ( match[ 3 ] ) {
1621				find.error( match[ 0 ] );
1622			}
1623
1624			return match;
1625		},
1626
1627		PSEUDO: function( match ) {
1628			var excess,
1629				unquoted = !match[ 6 ] && match[ 2 ];
1630
1631			if ( matchExpr.CHILD.test( match[ 0 ] ) ) {
1632				return null;
1633			}
1634
1635			// Accept quoted arguments as-is
1636			if ( match[ 3 ] ) {
1637				match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
1638
1639			// Strip excess characters from unquoted arguments
1640			} else if ( unquoted && rpseudo.test( unquoted ) &&
1641
1642				// Get excess from tokenize (recursively)
1643				( excess = tokenize( unquoted, true ) ) &&
1644
1645				// advance to the next closing parenthesis
1646				( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
1647
1648				// excess is a negative index
1649				match[ 0 ] = match[ 0 ].slice( 0, excess );
1650				match[ 2 ] = unquoted.slice( 0, excess );
1651			}
1652
1653			// Return only captures needed by the pseudo filter method (type and argument)
1654			return match.slice( 0, 3 );
1655		}
1656	},
1657
1658	filter: {
1659
1660		TAG: function( nodeNameSelector ) {
1661			var expectedNodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1662			return nodeNameSelector === "*" ?
1663				function() {
1664					return true;
1665				} :
1666				function( elem ) {
1667					return nodeName( elem, expectedNodeName );
1668				};
1669		},
1670
1671		CLASS: function( className ) {
1672			var pattern = classCache[ className + " " ];
1673
1674			return pattern ||
1675				( pattern = new RegExp( "(^|" + whitespace + ")" + className +
1676					"(" + whitespace + "|$)" ) ) &&
1677				classCache( className, function( elem ) {
1678					return pattern.test(
1679						typeof elem.className === "string" && elem.className ||
1680							typeof elem.getAttribute !== "undefined" &&
1681								elem.getAttribute( "class" ) ||
1682							""
1683					);
1684				} );
1685		},
1686
1687		ATTR: function( name, operator, check ) {
1688			return function( elem ) {
1689				var result = find.attr( elem, name );
1690
1691				if ( result == null ) {
1692					return operator === "!=";
1693				}
1694				if ( !operator ) {
1695					return true;
1696				}
1697
1698				result += "";
1699
1700				if ( operator === "=" ) {
1701					return result === check;
1702				}
1703				if ( operator === "!=" ) {
1704					return result !== check;
1705				}
1706				if ( operator === "^=" ) {
1707					return check && result.indexOf( check ) === 0;
1708				}
1709				if ( operator === "*=" ) {
1710					return check && result.indexOf( check ) > -1;
1711				}
1712				if ( operator === "$=" ) {
1713					return check && result.slice( -check.length ) === check;
1714				}
1715				if ( operator === "~=" ) {
1716					return ( " " + result.replace( rwhitespace, " " ) + " " )
1717						.indexOf( check ) > -1;
1718				}
1719				if ( operator === "|=" ) {
1720					return result === check || result.slice( 0, check.length + 1 ) === check + "-";
1721				}
1722
1723				return false;
1724			};
1725		},
1726
1727		CHILD: function( type, what, _argument, first, last ) {
1728			var simple = type.slice( 0, 3 ) !== "nth",
1729				forward = type.slice( -4 ) !== "last",
1730				ofType = what === "of-type";
1731
1732			return first === 1 && last === 0 ?
1733
1734				// Shortcut for :nth-*(n)
1735				function( elem ) {
1736					return !!elem.parentNode;
1737				} :
1738
1739				function( elem, _context, xml ) {
1740					var cache, outerCache, node, nodeIndex, start,
1741						dir = simple !== forward ? "nextSibling" : "previousSibling",
1742						parent = elem.parentNode,
1743						name = ofType && elem.nodeName.toLowerCase(),
1744						useCache = !xml && !ofType,
1745						diff = false;
1746
1747					if ( parent ) {
1748
1749						// :(first|last|only)-(child|of-type)
1750						if ( simple ) {
1751							while ( dir ) {
1752								node = elem;
1753								while ( ( node = node[ dir ] ) ) {
1754									if ( ofType ?
1755										nodeName( node, name ) :
1756										node.nodeType === 1 ) {
1757
1758										return false;
1759									}
1760								}
1761
1762								// Reverse direction for :only-* (if we haven't yet done so)
1763								start = dir = type === "only" && !start && "nextSibling";
1764							}
1765							return true;
1766						}
1767
1768						start = [ forward ? parent.firstChild : parent.lastChild ];
1769
1770						// non-xml :nth-child(...) stores cache data on `parent`
1771						if ( forward && useCache ) {
1772
1773							// Seek `elem` from a previously-cached index
1774							outerCache = parent[ expando ] || ( parent[ expando ] = {} );
1775							cache = outerCache[ type ] || [];
1776							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1777							diff = nodeIndex && cache[ 2 ];
1778							node = nodeIndex && parent.childNodes[ nodeIndex ];
1779
1780							while ( ( node = ++nodeIndex && node && node[ dir ] ||
1781
1782								// Fallback to seeking `elem` from the start
1783								( diff = nodeIndex = 0 ) || start.pop() ) ) {
1784
1785								// When found, cache indexes on `parent` and break
1786								if ( node.nodeType === 1 && ++diff && node === elem ) {
1787									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
1788									break;
1789								}
1790							}
1791
1792						} else {
1793
1794							// Use previously-cached element index if available
1795							if ( useCache ) {
1796								outerCache = elem[ expando ] || ( elem[ expando ] = {} );
1797								cache = outerCache[ type ] || [];
1798								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1799								diff = nodeIndex;
1800							}
1801
1802							// xml :nth-child(...)
1803							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
1804							if ( diff === false ) {
1805
1806								// Use the same loop as above to seek `elem` from the start
1807								while ( ( node = ++nodeIndex && node && node[ dir ] ||
1808									( diff = nodeIndex = 0 ) || start.pop() ) ) {
1809
1810									if ( ( ofType ?
1811										nodeName( node, name ) :
1812										node.nodeType === 1 ) &&
1813										++diff ) {
1814
1815										// Cache the index of each encountered element
1816										if ( useCache ) {
1817											outerCache = node[ expando ] ||
1818												( node[ expando ] = {} );
1819											outerCache[ type ] = [ dirruns, diff ];
1820										}
1821
1822										if ( node === elem ) {
1823											break;
1824										}
1825									}
1826								}
1827							}
1828						}
1829
1830						// Incorporate the offset, then check against cycle size
1831						diff -= last;
1832						return diff === first || ( diff % first === 0 && diff / first >= 0 );
1833					}
1834				};
1835		},
1836
1837		PSEUDO: function( pseudo, argument ) {
1838
1839			// pseudo-class names are case-insensitive
1840			// https://www.w3.org/TR/selectors/#pseudo-classes
1841			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1842			// Remember that setFilters inherits from pseudos
1843			var args,
1844				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1845					find.error( "unsupported pseudo: " + pseudo );
1846
1847			// The user may use createPseudo to indicate that
1848			// arguments are needed to create the filter function
1849			// just as jQuery does
1850			if ( fn[ expando ] ) {
1851				return fn( argument );
1852			}
1853
1854			// But maintain support for old signatures
1855			if ( fn.length > 1 ) {
1856				args = [ pseudo, pseudo, "", argument ];
1857				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
1858					markFunction( function( seed, matches ) {
1859						var idx,
1860							matched = fn( seed, argument ),
1861							i = matched.length;
1862						while ( i-- ) {
1863							idx = indexOf.call( seed, matched[ i ] );
1864							seed[ idx ] = !( matches[ idx ] = matched[ i ] );
1865						}
1866					} ) :
1867					function( elem ) {
1868						return fn( elem, 0, args );
1869					};
1870			}
1871
1872			return fn;
1873		}
1874	},
1875
1876	pseudos: {
1877
1878		// Potentially complex pseudos
1879		not: markFunction( function( selector ) {
1880
1881			// Trim the selector passed to compile
1882			// to avoid treating leading and trailing
1883			// spaces as combinators
1884			var input = [],
1885				results = [],
1886				matcher = compile( selector.replace( rtrimCSS, "$1" ) );
1887
1888			return matcher[ expando ] ?
1889				markFunction( function( seed, matches, _context, xml ) {
1890					var elem,
1891						unmatched = matcher( seed, null, xml, [] ),
1892						i = seed.length;
1893
1894					// Match elements unmatched by `matcher`
1895					while ( i-- ) {
1896						if ( ( elem = unmatched[ i ] ) ) {
1897							seed[ i ] = !( matches[ i ] = elem );
1898						}
1899					}
1900				} ) :
1901				function( elem, _context, xml ) {
1902					input[ 0 ] = elem;
1903					matcher( input, null, xml, results );
1904
1905					// Don't keep the element
1906					// (see https://github.com/jquery/sizzle/issues/299)
1907					input[ 0 ] = null;
1908					return !results.pop();
1909				};
1910		} ),
1911
1912		has: markFunction( function( selector ) {
1913			return function( elem ) {
1914				return find( selector, elem ).length > 0;
1915			};
1916		} ),
1917
1918		contains: markFunction( function( text ) {
1919			text = text.replace( runescape, funescape );
1920			return function( elem ) {
1921				return ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1;
1922			};
1923		} ),
1924
1925		// "Whether an element is represented by a :lang() selector
1926		// is based solely on the element's language value
1927		// being equal to the identifier C,
1928		// or beginning with the identifier C immediately followed by "-".
1929		// The matching of C against the element's language value is performed case-insensitively.
1930		// The identifier C does not have to be a valid language name."
1931		// https://www.w3.org/TR/selectors/#lang-pseudo
1932		lang: markFunction( function( lang ) {
1933
1934			// lang value must be a valid identifier
1935			if ( !ridentifier.test( lang || "" ) ) {
1936				find.error( "unsupported lang: " + lang );
1937			}
1938			lang = lang.replace( runescape, funescape ).toLowerCase();
1939			return function( elem ) {
1940				var elemLang;
1941				do {
1942					if ( ( elemLang = documentIsHTML ?
1943						elem.lang :
1944						elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
1945
1946						elemLang = elemLang.toLowerCase();
1947						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
1948					}
1949				} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
1950				return false;
1951			};
1952		} ),
1953
1954		// Miscellaneous
1955		target: function( elem ) {
1956			var hash = window.location && window.location.hash;
1957			return hash && hash.slice( 1 ) === elem.id;
1958		},
1959
1960		root: function( elem ) {
1961			return elem === documentElement;
1962		},
1963
1964		focus: function( elem ) {
1965			return elem === safeActiveElement() &&
1966				document.hasFocus() &&
1967				!!( elem.type || elem.href || ~elem.tabIndex );
1968		},
1969
1970		// Boolean properties
1971		enabled: createDisabledPseudo( false ),
1972		disabled: createDisabledPseudo( true ),
1973
1974		checked: function( elem ) {
1975
1976			// In CSS3, :checked should return both checked and selected elements
1977			// https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1978			return ( nodeName( elem, "input" ) && !!elem.checked ) ||
1979				( nodeName( elem, "option" ) && !!elem.selected );
1980		},
1981
1982		selected: function( elem ) {
1983
1984			// Support: IE <=11+
1985			// Accessing the selectedIndex property
1986			// forces the browser to treat the default option as
1987			// selected when in an optgroup.
1988			if ( elem.parentNode ) {
1989				// eslint-disable-next-line no-unused-expressions
1990				elem.parentNode.selectedIndex;
1991			}
1992
1993			return elem.selected === true;
1994		},
1995
1996		// Contents
1997		empty: function( elem ) {
1998
1999			// https://www.w3.org/TR/selectors/#empty-pseudo
2000			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2001			//   but not by others (comment: 8; processing instruction: 7; etc.)
2002			// nodeType < 6 works because attributes (2) do not appear as children
2003			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2004				if ( elem.nodeType < 6 ) {
2005					return false;
2006				}
2007			}
2008			return true;
2009		},
2010
2011		parent: function( elem ) {
2012			return !Expr.pseudos.empty( elem );
2013		},
2014
2015		// Element/input types
2016		header: function( elem ) {
2017			return rheader.test( elem.nodeName );
2018		},
2019
2020		input: function( elem ) {
2021			return rinputs.test( elem.nodeName );
2022		},
2023
2024		button: function( elem ) {
2025			return nodeName( elem, "input" ) && elem.type === "button" ||
2026				nodeName( elem, "button" );
2027		},
2028
2029		text: function( elem ) {
2030			var attr;
2031			return nodeName( elem, "input" ) && elem.type === "text" &&
2032
2033				// Support: IE <10 only
2034				// New HTML5 attribute values (e.g., "search") appear
2035				// with elem.type === "text"
2036				( ( attr = elem.getAttribute( "type" ) ) == null ||
2037					attr.toLowerCase() === "text" );
2038		},
2039
2040		// Position-in-collection
2041		first: createPositionalPseudo( function() {
2042			return [ 0 ];
2043		} ),
2044
2045		last: createPositionalPseudo( function( _matchIndexes, length ) {
2046			return [ length - 1 ];
2047		} ),
2048
2049		eq: createPositionalPseudo( function( _matchIndexes, length, argument ) {
2050			return [ argument < 0 ? argument + length : argument ];
2051		} ),
2052
2053		even: createPositionalPseudo( function( matchIndexes, length ) {
2054			var i = 0;
2055			for ( ; i < length; i += 2 ) {
2056				matchIndexes.push( i );
2057			}
2058			return matchIndexes;
2059		} ),
2060
2061		odd: createPositionalPseudo( function( matchIndexes, length ) {
2062			var i = 1;
2063			for ( ; i < length; i += 2 ) {
2064				matchIndexes.push( i );
2065			}
2066			return matchIndexes;
2067		} ),
2068
2069		lt: createPositionalPseudo( function( matchIndexes, length, argument ) {
2070			var i;
2071
2072			if ( argument < 0 ) {
2073				i = argument + length;
2074			} else if ( argument > length ) {
2075				i = length;
2076			} else {
2077				i = argument;
2078			}
2079
2080			for ( ; --i >= 0; ) {
2081				matchIndexes.push( i );
2082			}
2083			return matchIndexes;
2084		} ),
2085
2086		gt: createPositionalPseudo( function( matchIndexes, length, argument ) {
2087			var i = argument < 0 ? argument + length : argument;
2088			for ( ; ++i < length; ) {
2089				matchIndexes.push( i );
2090			}
2091			return matchIndexes;
2092		} )
2093	}
2094};
2095
2096Expr.pseudos.nth = Expr.pseudos.eq;
2097
2098// Add button/input type pseudos
2099for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2100	Expr.pseudos[ i ] = createInputPseudo( i );
2101}
2102for ( i in { submit: true, reset: true } ) {
2103	Expr.pseudos[ i ] = createButtonPseudo( i );
2104}
2105
2106// Easy API for creating new setFilters
2107function setFilters() {}
2108setFilters.prototype = Expr.filters = Expr.pseudos;
2109Expr.setFilters = new setFilters();
2110
2111function tokenize( selector, parseOnly ) {
2112	var matched, match, tokens, type,
2113		soFar, groups, preFilters,
2114		cached = tokenCache[ selector + " " ];
2115
2116	if ( cached ) {
2117		return parseOnly ? 0 : cached.slice( 0 );
2118	}
2119
2120	soFar = selector;
2121	groups = [];
2122	preFilters = Expr.preFilter;
2123
2124	while ( soFar ) {
2125
2126		// Comma and first run
2127		if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
2128			if ( match ) {
2129
2130				// Don't consume trailing commas as valid
2131				soFar = soFar.slice( match[ 0 ].length ) || soFar;
2132			}
2133			groups.push( ( tokens = [] ) );
2134		}
2135
2136		matched = false;
2137
2138		// Combinators
2139		if ( ( match = rleadingCombinator.exec( soFar ) ) ) {
2140			matched = match.shift();
2141			tokens.push( {
2142				value: matched,
2143
2144				// Cast descendant combinators to space
2145				type: match[ 0 ].replace( rtrimCSS, " " )
2146			} );
2147			soFar = soFar.slice( matched.length );
2148		}
2149
2150		// Filters
2151		for ( type in Expr.filter ) {
2152			if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
2153				( match = preFilters[ type ]( match ) ) ) ) {
2154				matched = match.shift();
2155				tokens.push( {
2156					value: matched,
2157					type: type,
2158					matches: match
2159				} );
2160				soFar = soFar.slice( matched.length );
2161			}
2162		}
2163
2164		if ( !matched ) {
2165			break;
2166		}
2167	}
2168
2169	// Return the length of the invalid excess
2170	// if we're just parsing
2171	// Otherwise, throw an error or return tokens
2172	if ( parseOnly ) {
2173		return soFar.length;
2174	}
2175
2176	return soFar ?
2177		find.error( selector ) :
2178
2179		// Cache the tokens
2180		tokenCache( selector, groups ).slice( 0 );
2181}
2182
2183function toSelector( tokens ) {
2184	var i = 0,
2185		len = tokens.length,
2186		selector = "";
2187	for ( ; i < len; i++ ) {
2188		selector += tokens[ i ].value;
2189	}
2190	return selector;
2191}
2192
2193function addCombinator( matcher, combinator, base ) {
2194	var dir = combinator.dir,
2195		skip = combinator.next,
2196		key = skip || dir,
2197		checkNonElements = base && key === "parentNode",
2198		doneName = done++;
2199
2200	return combinator.first ?
2201
2202		// Check against closest ancestor/preceding element
2203		function( elem, context, xml ) {
2204			while ( ( elem = elem[ dir ] ) ) {
2205				if ( elem.nodeType === 1 || checkNonElements ) {
2206					return matcher( elem, context, xml );
2207				}
2208			}
2209			return false;
2210		} :
2211
2212		// Check against all ancestor/preceding elements
2213		function( elem, context, xml ) {
2214			var oldCache, outerCache,
2215				newCache = [ dirruns, doneName ];
2216
2217			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2218			if ( xml ) {
2219				while ( ( elem = elem[ dir ] ) ) {
2220					if ( elem.nodeType === 1 || checkNonElements ) {
2221						if ( matcher( elem, context, xml ) ) {
2222							return true;
2223						}
2224					}
2225				}
2226			} else {
2227				while ( ( elem = elem[ dir ] ) ) {
2228					if ( elem.nodeType === 1 || checkNonElements ) {
2229						outerCache = elem[ expando ] || ( elem[ expando ] = {} );
2230
2231						if ( skip && nodeName( elem, skip ) ) {
2232							elem = elem[ dir ] || elem;
2233						} else if ( ( oldCache = outerCache[ key ] ) &&
2234							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2235
2236							// Assign to newCache so results back-propagate to previous elements
2237							return ( newCache[ 2 ] = oldCache[ 2 ] );
2238						} else {
2239
2240							// Reuse newcache so results back-propagate to previous elements
2241							outerCache[ key ] = newCache;
2242
2243							// A match means we're done; a fail means we have to keep checking
2244							if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
2245								return true;
2246							}
2247						}
2248					}
2249				}
2250			}
2251			return false;
2252		};
2253}
2254
2255function elementMatcher( matchers ) {
2256	return matchers.length > 1 ?
2257		function( elem, context, xml ) {
2258			var i = matchers.length;
2259			while ( i-- ) {
2260				if ( !matchers[ i ]( elem, context, xml ) ) {
2261					return false;
2262				}
2263			}
2264			return true;
2265		} :
2266		matchers[ 0 ];
2267}
2268
2269function multipleContexts( selector, contexts, results ) {
2270	var i = 0,
2271		len = contexts.length;
2272	for ( ; i < len; i++ ) {
2273		find( selector, contexts[ i ], results );
2274	}
2275	return results;
2276}
2277
2278function condense( unmatched, map, filter, context, xml ) {
2279	var elem,
2280		newUnmatched = [],
2281		i = 0,
2282		len = unmatched.length,
2283		mapped = map != null;
2284
2285	for ( ; i < len; i++ ) {
2286		if ( ( elem = unmatched[ i ] ) ) {
2287			if ( !filter || filter( elem, context, xml ) ) {
2288				newUnmatched.push( elem );
2289				if ( mapped ) {
2290					map.push( i );
2291				}
2292			}
2293		}
2294	}
2295
2296	return newUnmatched;
2297}
2298
2299function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2300	if ( postFilter && !postFilter[ expando ] ) {
2301		postFilter = setMatcher( postFilter );
2302	}
2303	if ( postFinder && !postFinder[ expando ] ) {
2304		postFinder = setMatcher( postFinder, postSelector );
2305	}
2306	return markFunction( function( seed, results, context, xml ) {
2307		var temp, i, elem, matcherOut,
2308			preMap = [],
2309			postMap = [],
2310			preexisting = results.length,
2311
2312			// Get initial elements from seed or context
2313			elems = seed ||
2314				multipleContexts( selector || "*",
2315					context.nodeType ? [ context ] : context, [] ),
2316
2317			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2318			matcherIn = preFilter && ( seed || !selector ) ?
2319				condense( elems, preMap, preFilter, context, xml ) :
2320				elems;
2321
2322		if ( matcher ) {
2323
2324			// If we have a postFinder, or filtered seed, or non-seed postFilter
2325			// or preexisting results,
2326			matcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2327
2328				// ...intermediate processing is necessary
2329				[] :
2330
2331				// ...otherwise use results directly
2332				results;
2333
2334			// Find primary matches
2335			matcher( matcherIn, matcherOut, context, xml );
2336		} else {
2337			matcherOut = matcherIn;
2338		}
2339
2340		// Apply postFilter
2341		if ( postFilter ) {
2342			temp = condense( matcherOut, postMap );
2343			postFilter( temp, [], context, xml );
2344
2345			// Un-match failing elements by moving them back to matcherIn
2346			i = temp.length;
2347			while ( i-- ) {
2348				if ( ( elem = temp[ i ] ) ) {
2349					matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
2350				}
2351			}
2352		}
2353
2354		if ( seed ) {
2355			if ( postFinder || preFilter ) {
2356				if ( postFinder ) {
2357
2358					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2359					temp = [];
2360					i = matcherOut.length;
2361					while ( i-- ) {
2362						if ( ( elem = matcherOut[ i ] ) ) {
2363
2364							// Restore matcherIn since elem is not yet a final match
2365							temp.push( ( matcherIn[ i ] = elem ) );
2366						}
2367					}
2368					postFinder( null, ( matcherOut = [] ), temp, xml );
2369				}
2370
2371				// Move matched elements from seed to results to keep them synchronized
2372				i = matcherOut.length;
2373				while ( i-- ) {
2374					if ( ( elem = matcherOut[ i ] ) &&
2375						( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) {
2376
2377						seed[ temp ] = !( results[ temp ] = elem );
2378					}
2379				}
2380			}
2381
2382		// Add elements to results, through postFinder if defined
2383		} else {
2384			matcherOut = condense(
2385				matcherOut === results ?
2386					matcherOut.splice( preexisting, matcherOut.length ) :
2387					matcherOut
2388			);
2389			if ( postFinder ) {
2390				postFinder( null, results, matcherOut, xml );
2391			} else {
2392				push.apply( results, matcherOut );
2393			}
2394		}
2395	} );
2396}
2397
2398function matcherFromTokens( tokens ) {
2399	var checkContext, matcher, j,
2400		len = tokens.length,
2401		leadingRelative = Expr.relative[ tokens[ 0 ].type ],
2402		implicitRelative = leadingRelative || Expr.relative[ " " ],
2403		i = leadingRelative ? 1 : 0,
2404
2405		// The foundational matcher ensures that elements are reachable from top-level context(s)
2406		matchContext = addCombinator( function( elem ) {
2407			return elem === checkContext;
2408		}, implicitRelative, true ),
2409		matchAnyContext = addCombinator( function( elem ) {
2410			return indexOf.call( checkContext, elem ) > -1;
2411		}, implicitRelative, true ),
2412		matchers = [ function( elem, context, xml ) {
2413
2414			// Support: IE 11+, Edge 17 - 18+
2415			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2416			// two documents; shallow comparisons work.
2417			// eslint-disable-next-line eqeqeq
2418			var ret = ( !leadingRelative && ( xml || context != outermostContext ) ) || (
2419				( checkContext = context ).nodeType ?
2420					matchContext( elem, context, xml ) :
2421					matchAnyContext( elem, context, xml ) );
2422
2423			// Avoid hanging onto element
2424			// (see https://github.com/jquery/sizzle/issues/299)
2425			checkContext = null;
2426			return ret;
2427		} ];
2428
2429	for ( ; i < len; i++ ) {
2430		if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
2431			matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
2432		} else {
2433			matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
2434
2435			// Return special upon seeing a positional matcher
2436			if ( matcher[ expando ] ) {
2437
2438				// Find the next relative operator (if any) for proper handling
2439				j = ++i;
2440				for ( ; j < len; j++ ) {
2441					if ( Expr.relative[ tokens[ j ].type ] ) {
2442						break;
2443					}
2444				}
2445				return setMatcher(
2446					i > 1 && elementMatcher( matchers ),
2447					i > 1 && toSelector(
2448
2449						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2450						tokens.slice( 0, i - 1 )
2451							.concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
2452					).replace( rtrimCSS, "$1" ),
2453					matcher,
2454					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2455					j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
2456					j < len && toSelector( tokens )
2457				);
2458			}
2459			matchers.push( matcher );
2460		}
2461	}
2462
2463	return elementMatcher( matchers );
2464}
2465
2466function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2467	var bySet = setMatchers.length > 0,
2468		byElement = elementMatchers.length > 0,
2469		superMatcher = function( seed, context, xml, results, outermost ) {
2470			var elem, j, matcher,
2471				matchedCount = 0,
2472				i = "0",
2473				unmatched = seed && [],
2474				setMatched = [],
2475				contextBackup = outermostContext,
2476
2477				// We must always have either seed elements or outermost context
2478				elems = seed || byElement && Expr.find.TAG( "*", outermost ),
2479
2480				// Use integer dirruns iff this is the outermost matcher
2481				dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
2482				len = elems.length;
2483
2484			if ( outermost ) {
2485
2486				// Support: IE 11+, Edge 17 - 18+
2487				// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2488				// two documents; shallow comparisons work.
2489				// eslint-disable-next-line eqeqeq
2490				outermostContext = context == document || context || outermost;
2491			}
2492
2493			// Add elements passing elementMatchers directly to results
2494			// Support: iOS <=7 - 9 only
2495			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching
2496			// elements by id. (see trac-14142)
2497			for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
2498				if ( byElement && elem ) {
2499					j = 0;
2500
2501					// Support: IE 11+, Edge 17 - 18+
2502					// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2503					// two documents; shallow comparisons work.
2504					// eslint-disable-next-line eqeqeq
2505					if ( !context && elem.ownerDocument != document ) {
2506						setDocument( elem );
2507						xml = !documentIsHTML;
2508					}
2509					while ( ( matcher = elementMatchers[ j++ ] ) ) {
2510						if ( matcher( elem, context || document, xml ) ) {
2511							push.call( results, elem );
2512							break;
2513						}
2514					}
2515					if ( outermost ) {
2516						dirruns = dirrunsUnique;
2517					}
2518				}
2519
2520				// Track unmatched elements for set filters
2521				if ( bySet ) {
2522
2523					// They will have gone through all possible matchers
2524					if ( ( elem = !matcher && elem ) ) {
2525						matchedCount--;
2526					}
2527
2528					// Lengthen the array for every element, matched or not
2529					if ( seed ) {
2530						unmatched.push( elem );
2531					}
2532				}
2533			}
2534
2535			// `i` is now the count of elements visited above, and adding it to `matchedCount`
2536			// makes the latter nonnegative.
2537			matchedCount += i;
2538
2539			// Apply set filters to unmatched elements
2540			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2541			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2542			// no element matchers and no seed.
2543			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2544			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2545			// numerically zero.
2546			if ( bySet && i !== matchedCount ) {
2547				j = 0;
2548				while ( ( matcher = setMatchers[ j++ ] ) ) {
2549					matcher( unmatched, setMatched, context, xml );
2550				}
2551
2552				if ( seed ) {
2553
2554					// Reintegrate element matches to eliminate the need for sorting
2555					if ( matchedCount > 0 ) {
2556						while ( i-- ) {
2557							if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
2558								setMatched[ i ] = pop.call( results );
2559							}
2560						}
2561					}
2562
2563					// Discard index placeholder values to get only actual matches
2564					setMatched = condense( setMatched );
2565				}
2566
2567				// Add matches to results
2568				push.apply( results, setMatched );
2569
2570				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2571				if ( outermost && !seed && setMatched.length > 0 &&
2572					( matchedCount + setMatchers.length ) > 1 ) {
2573
2574					jQuery.uniqueSort( results );
2575				}
2576			}
2577
2578			// Override manipulation of globals by nested matchers
2579			if ( outermost ) {
2580				dirruns = dirrunsUnique;
2581				outermostContext = contextBackup;
2582			}
2583
2584			return unmatched;
2585		};
2586
2587	return bySet ?
2588		markFunction( superMatcher ) :
2589		superMatcher;
2590}
2591
2592function compile( selector, match /* Internal Use Only */ ) {
2593	var i,
2594		setMatchers = [],
2595		elementMatchers = [],
2596		cached = compilerCache[ selector + " " ];
2597
2598	if ( !cached ) {
2599
2600		// Generate a function of recursive functions that can be used to check each element
2601		if ( !match ) {
2602			match = tokenize( selector );
2603		}
2604		i = match.length;
2605		while ( i-- ) {
2606			cached = matcherFromTokens( match[ i ] );
2607			if ( cached[ expando ] ) {
2608				setMatchers.push( cached );
2609			} else {
2610				elementMatchers.push( cached );
2611			}
2612		}
2613
2614		// Cache the compiled function
2615		cached = compilerCache( selector,
2616			matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2617
2618		// Save selector and tokenization
2619		cached.selector = selector;
2620	}
2621	return cached;
2622}
2623
2624/**
2625 * A low-level selection function that works with jQuery's compiled
2626 *  selector functions
2627 * @param {String|Function} selector A selector or a pre-compiled
2628 *  selector function built with jQuery selector compile
2629 * @param {Element} context
2630 * @param {Array} [results]
2631 * @param {Array} [seed] A set of elements to match against
2632 */
2633function select( selector, context, results, seed ) {
2634	var i, tokens, token, type, find,
2635		compiled = typeof selector === "function" && selector,
2636		match = !seed && tokenize( ( selector = compiled.selector || selector ) );
2637
2638	results = results || [];
2639
2640	// Try to minimize operations if there is only one selector in the list and no seed
2641	// (the latter of which guarantees us context)
2642	if ( match.length === 1 ) {
2643
2644		// Reduce context if the leading compound selector is an ID
2645		tokens = match[ 0 ] = match[ 0 ].slice( 0 );
2646		if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
2647				context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
2648
2649			context = ( Expr.find.ID(
2650				token.matches[ 0 ].replace( runescape, funescape ),
2651				context
2652			) || [] )[ 0 ];
2653			if ( !context ) {
2654				return results;
2655
2656			// Precompiled matchers will still verify ancestry, so step up a level
2657			} else if ( compiled ) {
2658				context = context.parentNode;
2659			}
2660
2661			selector = selector.slice( tokens.shift().value.length );
2662		}
2663
2664		// Fetch a seed set for right-to-left matching
2665		i = matchExpr.needsContext.test( selector ) ? 0 : tokens.length;
2666		while ( i-- ) {
2667			token = tokens[ i ];
2668
2669			// Abort if we hit a combinator
2670			if ( Expr.relative[ ( type = token.type ) ] ) {
2671				break;
2672			}
2673			if ( ( find = Expr.find[ type ] ) ) {
2674
2675				// Search, expanding context for leading sibling combinators
2676				if ( ( seed = find(
2677					token.matches[ 0 ].replace( runescape, funescape ),
2678					rsibling.test( tokens[ 0 ].type ) &&
2679						testContext( context.parentNode ) || context
2680				) ) ) {
2681
2682					// If seed is empty or no tokens remain, we can return early
2683					tokens.splice( i, 1 );
2684					selector = seed.length && toSelector( tokens );
2685					if ( !selector ) {
2686						push.apply( results, seed );
2687						return results;
2688					}
2689
2690					break;
2691				}
2692			}
2693		}
2694	}
2695
2696	// Compile and execute a filtering function if one is not provided
2697	// Provide `match` to avoid retokenization if we modified the selector above
2698	( compiled || compile( selector, match ) )(
2699		seed,
2700		context,
2701		!documentIsHTML,
2702		results,
2703		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2704	);
2705	return results;
2706}
2707
2708// One-time assignments
2709
2710// Support: Android <=4.0 - 4.1+
2711// Sort stability
2712support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
2713
2714// Initialize against the default document
2715setDocument();
2716
2717// Support: Android <=4.0 - 4.1+
2718// Detached nodes confoundingly follow *each other*
2719support.sortDetached = assert( function( el ) {
2720
2721	// Should return 1, but returns 4 (following)
2722	return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
2723} );
2724
2725jQuery.find = find;
2726
2727// Deprecated
2728jQuery.expr[ ":" ] = jQuery.expr.pseudos;
2729jQuery.unique = jQuery.uniqueSort;
2730
2731// These have always been private, but they used to be documented
2732// as part of Sizzle so let's maintain them in the 3.x line
2733// for backwards compatibility purposes.
2734find.compile = compile;
2735find.select = select;
2736find.setDocument = setDocument;
2737
2738find.escape = jQuery.escapeSelector;
2739find.getText = jQuery.text;
2740find.isXML = jQuery.isXMLDoc;
2741find.selectors = jQuery.expr;
2742find.support = jQuery.support;
2743find.uniqueSort = jQuery.uniqueSort;
2744
2745	/* eslint-enable */
2746
2747} )();
2748
2749
2750var dir = function( elem, dir, until ) {
2751	var matched = [],
2752		truncate = until !== undefined;
2753
2754	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
2755		if ( elem.nodeType === 1 ) {
2756			if ( truncate && jQuery( elem ).is( until ) ) {
2757				break;
2758			}
2759			matched.push( elem );
2760		}
2761	}
2762	return matched;
2763};
2764
2765
2766var siblings = function( n, elem ) {
2767	var matched = [];
2768
2769	for ( ; n; n = n.nextSibling ) {
2770		if ( n.nodeType === 1 && n !== elem ) {
2771			matched.push( n );
2772		}
2773	}
2774
2775	return matched;
2776};
2777
2778
2779var rneedsContext = jQuery.expr.match.needsContext;
2780
2781var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
2782
2783
2784
2785// Implement the identical functionality for filter and not
2786function winnow( elements, qualifier, not ) {
2787	if ( isFunction( qualifier ) ) {
2788		return jQuery.grep( elements, function( elem, i ) {
2789			return !!qualifier.call( elem, i, elem ) !== not;
2790		} );
2791	}
2792
2793	// Single element
2794	if ( qualifier.nodeType ) {
2795		return jQuery.grep( elements, function( elem ) {
2796			return ( elem === qualifier ) !== not;
2797		} );
2798	}
2799
2800	// Arraylike of elements (jQuery, arguments, Array)
2801	if ( typeof qualifier !== "string" ) {
2802		return jQuery.grep( elements, function( elem ) {
2803			return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
2804		} );
2805	}
2806
2807	// Filtered directly for both simple and complex selectors
2808	return jQuery.filter( qualifier, elements, not );
2809}
2810
2811jQuery.filter = function( expr, elems, not ) {
2812	var elem = elems[ 0 ];
2813
2814	if ( not ) {
2815		expr = ":not(" + expr + ")";
2816	}
2817
2818	if ( elems.length === 1 && elem.nodeType === 1 ) {
2819		return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
2820	}
2821
2822	return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
2823		return elem.nodeType === 1;
2824	} ) );
2825};
2826
2827jQuery.fn.extend( {
2828	find: function( selector ) {
2829		var i, ret,
2830			len = this.length,
2831			self = this;
2832
2833		if ( typeof selector !== "string" ) {
2834			return this.pushStack( jQuery( selector ).filter( function() {
2835				for ( i = 0; i < len; i++ ) {
2836					if ( jQuery.contains( self[ i ], this ) ) {
2837						return true;
2838					}
2839				}
2840			} ) );
2841		}
2842
2843		ret = this.pushStack( [] );
2844
2845		for ( i = 0; i < len; i++ ) {
2846			jQuery.find( selector, self[ i ], ret );
2847		}
2848
2849		return len > 1 ? jQuery.uniqueSort( ret ) : ret;
2850	},
2851	filter: function( selector ) {
2852		return this.pushStack( winnow( this, selector || [], false ) );
2853	},
2854	not: function( selector ) {
2855		return this.pushStack( winnow( this, selector || [], true ) );
2856	},
2857	is: function( selector ) {
2858		return !!winnow(
2859			this,
2860
2861			// If this is a positional/relative selector, check membership in the returned set
2862			// so $("p:first").is("p:last") won't return true for a doc with two "p".
2863			typeof selector === "string" && rneedsContext.test( selector ) ?
2864				jQuery( selector ) :
2865				selector || [],
2866			false
2867		).length;
2868	}
2869} );
2870
2871
2872// Initialize a jQuery object
2873
2874
2875// A central reference to the root jQuery(document)
2876var rootjQuery,
2877
2878	// A simple way to check for HTML strings
2879	// Prioritize #id over <tag> to avoid XSS via location.hash (trac-9521)
2880	// Strict HTML recognition (trac-11290: must start with <)
2881	// Shortcut simple #id case for speed
2882	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
2883
2884	init = jQuery.fn.init = function( selector, context, root ) {
2885		var match, elem;
2886
2887		// HANDLE: $(""), $(null), $(undefined), $(false)
2888		if ( !selector ) {
2889			return this;
2890		}
2891
2892		// Method init() accepts an alternate rootjQuery
2893		// so migrate can support jQuery.sub (gh-2101)
2894		root = root || rootjQuery;
2895
2896		// Handle HTML strings
2897		if ( typeof selector === "string" ) {
2898			if ( selector[ 0 ] === "<" &&
2899				selector[ selector.length - 1 ] === ">" &&
2900				selector.length >= 3 ) {
2901
2902				// Assume that strings that start and end with <> are HTML and skip the regex check
2903				match = [ null, selector, null ];
2904
2905			} else {
2906				match = rquickExpr.exec( selector );
2907			}
2908
2909			// Match html or make sure no context is specified for #id
2910			if ( match && ( match[ 1 ] || !context ) ) {
2911
2912				// HANDLE: $(html) -> $(array)
2913				if ( match[ 1 ] ) {
2914					context = context instanceof jQuery ? context[ 0 ] : context;
2915
2916					// Option to run scripts is true for back-compat
2917					// Intentionally let the error be thrown if parseHTML is not present
2918					jQuery.merge( this, jQuery.parseHTML(
2919						match[ 1 ],
2920						context && context.nodeType ? context.ownerDocument || context : document,
2921						true
2922					) );
2923
2924					// HANDLE: $(html, props)
2925					if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
2926						for ( match in context ) {
2927
2928							// Properties of context are called as methods if possible
2929							if ( isFunction( this[ match ] ) ) {
2930								this[ match ]( context[ match ] );
2931
2932							// ...and otherwise set as attributes
2933							} else {
2934								this.attr( match, context[ match ] );
2935							}
2936						}
2937					}
2938
2939					return this;
2940
2941				// HANDLE: $(#id)
2942				} else {
2943					elem = document.getElementById( match[ 2 ] );
2944
2945					if ( elem ) {
2946
2947						// Inject the element directly into the jQuery object
2948						this[ 0 ] = elem;
2949						this.length = 1;
2950					}
2951					return this;
2952				}
2953
2954			// HANDLE: $(expr, $(...))
2955			} else if ( !context || context.jquery ) {
2956				return ( context || root ).find( selector );
2957
2958			// HANDLE: $(expr, context)
2959			// (which is just equivalent to: $(context).find(expr)
2960			} else {
2961				return this.constructor( context ).find( selector );
2962			}
2963
2964		// HANDLE: $(DOMElement)
2965		} else if ( selector.nodeType ) {
2966			this[ 0 ] = selector;
2967			this.length = 1;
2968			return this;
2969
2970		// HANDLE: $(function)
2971		// Shortcut for document ready
2972		} else if ( isFunction( selector ) ) {
2973			return root.ready !== undefined ?
2974				root.ready( selector ) :
2975
2976				// Execute immediately if ready is not present
2977				selector( jQuery );
2978		}
2979
2980		return jQuery.makeArray( selector, this );
2981	};
2982
2983// Give the init function the jQuery prototype for later instantiation
2984init.prototype = jQuery.fn;
2985
2986// Initialize central reference
2987rootjQuery = jQuery( document );
2988
2989
2990var rparentsprev = /^(?:parents|prev(?:Until|All))/,
2991
2992	// Methods guaranteed to produce a unique set when starting from a unique set
2993	guaranteedUnique = {
2994		children: true,
2995		contents: true,
2996		next: true,
2997		prev: true
2998	};
2999
3000jQuery.fn.extend( {
3001	has: function( target ) {
3002		var targets = jQuery( target, this ),
3003			l = targets.length;
3004
3005		return this.filter( function() {
3006			var i = 0;
3007			for ( ; i < l; i++ ) {
3008				if ( jQuery.contains( this, targets[ i ] ) ) {
3009					return true;
3010				}
3011			}
3012		} );
3013	},
3014
3015	closest: function( selectors, context ) {
3016		var cur,
3017			i = 0,
3018			l = this.length,
3019			matched = [],
3020			targets = typeof selectors !== "string" && jQuery( selectors );
3021
3022		// Positional selectors never match, since there's no _selection_ context
3023		if ( !rneedsContext.test( selectors ) ) {
3024			for ( ; i < l; i++ ) {
3025				for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
3026
3027					// Always skip document fragments
3028					if ( cur.nodeType < 11 && ( targets ?
3029						targets.index( cur ) > -1 :
3030
3031						// Don't pass non-elements to jQuery#find
3032						cur.nodeType === 1 &&
3033							jQuery.find.matchesSelector( cur, selectors ) ) ) {
3034
3035						matched.push( cur );
3036						break;
3037					}
3038				}
3039			}
3040		}
3041
3042		return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
3043	},
3044
3045	// Determine the position of an element within the set
3046	index: function( elem ) {
3047
3048		// No argument, return index in parent
3049		if ( !elem ) {
3050			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
3051		}
3052
3053		// Index in selector
3054		if ( typeof elem === "string" ) {
3055			return indexOf.call( jQuery( elem ), this[ 0 ] );
3056		}
3057
3058		// Locate the position of the desired element
3059		return indexOf.call( this,
3060
3061			// If it receives a jQuery object, the first element is used
3062			elem.jquery ? elem[ 0 ] : elem
3063		);
3064	},
3065
3066	add: function( selector, context ) {
3067		return this.pushStack(
3068			jQuery.uniqueSort(
3069				jQuery.merge( this.get(), jQuery( selector, context ) )
3070			)
3071		);
3072	},
3073
3074	addBack: function( selector ) {
3075		return this.add( selector == null ?
3076			this.prevObject : this.prevObject.filter( selector )
3077		);
3078	}
3079} );
3080
3081function sibling( cur, dir ) {
3082	while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
3083	return cur;
3084}
3085
3086jQuery.each( {
3087	parent: function( elem ) {
3088		var parent = elem.parentNode;
3089		return parent && parent.nodeType !== 11 ? parent : null;
3090	},
3091	parents: function( elem ) {
3092		return dir( elem, "parentNode" );
3093	},
3094	parentsUntil: function( elem, _i, until ) {
3095		return dir( elem, "parentNode", until );
3096	},
3097	next: function( elem ) {
3098		return sibling( elem, "nextSibling" );
3099	},
3100	prev: function( elem ) {
3101		return sibling( elem, "previousSibling" );
3102	},
3103	nextAll: function( elem ) {
3104		return dir( elem, "nextSibling" );
3105	},
3106	prevAll: function( elem ) {
3107		return dir( elem, "previousSibling" );
3108	},
3109	nextUntil: function( elem, _i, until ) {
3110		return dir( elem, "nextSibling", until );
3111	},
3112	prevUntil: function( elem, _i, until ) {
3113		return dir( elem, "previousSibling", until );
3114	},
3115	siblings: function( elem ) {
3116		return siblings( ( elem.parentNode || {} ).firstChild, elem );
3117	},
3118	children: function( elem ) {
3119		return siblings( elem.firstChild );
3120	},
3121	contents: function( elem ) {
3122		if ( elem.contentDocument != null &&
3123
3124			// Support: IE 11+
3125			// <object> elements with no `data` attribute has an object
3126			// `contentDocument` with a `null` prototype.
3127			getProto( elem.contentDocument ) ) {
3128
3129			return elem.contentDocument;
3130		}
3131
3132		// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
3133		// Treat the template element as a regular one in browsers that
3134		// don't support it.
3135		if ( nodeName( elem, "template" ) ) {
3136			elem = elem.content || elem;
3137		}
3138
3139		return jQuery.merge( [], elem.childNodes );
3140	}
3141}, function( name, fn ) {
3142	jQuery.fn[ name ] = function( until, selector ) {
3143		var matched = jQuery.map( this, fn, until );
3144
3145		if ( name.slice( -5 ) !== "Until" ) {
3146			selector = until;
3147		}
3148
3149		if ( selector && typeof selector === "string" ) {
3150			matched = jQuery.filter( selector, matched );
3151		}
3152
3153		if ( this.length > 1 ) {
3154
3155			// Remove duplicates
3156			if ( !guaranteedUnique[ name ] ) {
3157				jQuery.uniqueSort( matched );
3158			}
3159
3160			// Reverse order for parents* and prev-derivatives
3161			if ( rparentsprev.test( name ) ) {
3162				matched.reverse();
3163			}
3164		}
3165
3166		return this.pushStack( matched );
3167	};
3168} );
3169var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
3170
3171
3172
3173// Convert String-formatted options into Object-formatted ones
3174function createOptions( options ) {
3175	var object = {};
3176	jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
3177		object[ flag ] = true;
3178	} );
3179	return object;
3180}
3181
3182/*
3183 * Create a callback list using the following parameters:
3184 *
3185 *	options: an optional list of space-separated options that will change how
3186 *			the callback list behaves or a more traditional option object
3187 *
3188 * By default a callback list will act like an event callback list and can be
3189 * "fired" multiple times.
3190 *
3191 * Possible options:
3192 *
3193 *	once:			will ensure the callback list can only be fired once (like a Deferred)
3194 *
3195 *	memory:			will keep track of previous values and will call any callback added
3196 *					after the list has been fired right away with the latest "memorized"
3197 *					values (like a Deferred)
3198 *
3199 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
3200 *
3201 *	stopOnFalse:	interrupt callings when a callback returns false
3202 *
3203 */
3204jQuery.Callbacks = function( options ) {
3205
3206	// Convert options from String-formatted to Object-formatted if needed
3207	// (we check in cache first)
3208	options = typeof options === "string" ?
3209		createOptions( options ) :
3210		jQuery.extend( {}, options );
3211
3212	var // Flag to know if list is currently firing
3213		firing,
3214
3215		// Last fire value for non-forgettable lists
3216		memory,
3217
3218		// Flag to know if list was already fired
3219		fired,
3220
3221		// Flag to prevent firing
3222		locked,
3223
3224		// Actual callback list
3225		list = [],
3226
3227		// Queue of execution data for repeatable lists
3228		queue = [],
3229
3230		// Index of currently firing callback (modified by add/remove as needed)
3231		firingIndex = -1,
3232
3233		// Fire callbacks
3234		fire = function() {
3235
3236			// Enforce single-firing
3237			locked = locked || options.once;
3238
3239			// Execute callbacks for all pending executions,
3240			// respecting firingIndex overrides and runtime changes
3241			fired = firing = true;
3242			for ( ; queue.length; firingIndex = -1 ) {
3243				memory = queue.shift();
3244				while ( ++firingIndex < list.length ) {
3245
3246					// Run callback and check for early termination
3247					if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
3248						options.stopOnFalse ) {
3249
3250						// Jump to end and forget the data so .add doesn't re-fire
3251						firingIndex = list.length;
3252						memory = false;
3253					}
3254				}
3255			}
3256
3257			// Forget the data if we're done with it
3258			if ( !options.memory ) {
3259				memory = false;
3260			}
3261
3262			firing = false;
3263
3264			// Clean up if we're done firing for good
3265			if ( locked ) {
3266
3267				// Keep an empty list if we have data for future add calls
3268				if ( memory ) {
3269					list = [];
3270
3271				// Otherwise, this object is spent
3272				} else {
3273					list = "";
3274				}
3275			}
3276		},
3277
3278		// Actual Callbacks object
3279		self = {
3280
3281			// Add a callback or a collection of callbacks to the list
3282			add: function() {
3283				if ( list ) {
3284
3285					// If we have memory from a past run, we should fire after adding
3286					if ( memory && !firing ) {
3287						firingIndex = list.length - 1;
3288						queue.push( memory );
3289					}
3290
3291					( function add( args ) {
3292						jQuery.each( args, function( _, arg ) {
3293							if ( isFunction( arg ) ) {
3294								if ( !options.unique || !self.has( arg ) ) {
3295									list.push( arg );
3296								}
3297							} else if ( arg && arg.length && toType( arg ) !== "string" ) {
3298
3299								// Inspect recursively
3300								add( arg );
3301							}
3302						} );
3303					} )( arguments );
3304
3305					if ( memory && !firing ) {
3306						fire();
3307					}
3308				}
3309				return this;
3310			},
3311
3312			// Remove a callback from the list
3313			remove: function() {
3314				jQuery.each( arguments, function( _, arg ) {
3315					var index;
3316					while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
3317						list.splice( index, 1 );
3318
3319						// Handle firing indexes
3320						if ( index <= firingIndex ) {
3321							firingIndex--;
3322						}
3323					}
3324				} );
3325				return this;
3326			},
3327
3328			// Check if a given callback is in the list.
3329			// If no argument is given, return whether or not list has callbacks attached.
3330			has: function( fn ) {
3331				return fn ?
3332					jQuery.inArray( fn, list ) > -1 :
3333					list.length > 0;
3334			},
3335
3336			// Remove all callbacks from the list
3337			empty: function() {
3338				if ( list ) {
3339					list = [];
3340				}
3341				return this;
3342			},
3343
3344			// Disable .fire and .add
3345			// Abort any current/pending executions
3346			// Clear all callbacks and values
3347			disable: function() {
3348				locked = queue = [];
3349				list = memory = "";
3350				return this;
3351			},
3352			disabled: function() {
3353				return !list;
3354			},
3355
3356			// Disable .fire
3357			// Also disable .add unless we have memory (since it would have no effect)
3358			// Abort any pending executions
3359			lock: function() {
3360				locked = queue = [];
3361				if ( !memory && !firing ) {
3362					list = memory = "";
3363				}
3364				return this;
3365			},
3366			locked: function() {
3367				return !!locked;
3368			},
3369
3370			// Call all callbacks with the given context and arguments
3371			fireWith: function( context, args ) {
3372				if ( !locked ) {
3373					args = args || [];
3374					args = [ context, args.slice ? args.slice() : args ];
3375					queue.push( args );
3376					if ( !firing ) {
3377						fire();
3378					}
3379				}
3380				return this;
3381			},
3382
3383			// Call all the callbacks with the given arguments
3384			fire: function() {
3385				self.fireWith( this, arguments );
3386				return this;
3387			},
3388
3389			// To know if the callbacks have already been called at least once
3390			fired: function() {
3391				return !!fired;
3392			}
3393		};
3394
3395	return self;
3396};
3397
3398
3399function Identity( v ) {
3400	return v;
3401}
3402function Thrower( ex ) {
3403	throw ex;
3404}
3405
3406function adoptValue( value, resolve, reject, noValue ) {
3407	var method;
3408
3409	try {
3410
3411		// Check for promise aspect first to privilege synchronous behavior
3412		if ( value && isFunction( ( method = value.promise ) ) ) {
3413			method.call( value ).done( resolve ).fail( reject );
3414
3415		// Other thenables
3416		} else if ( value && isFunction( ( method = value.then ) ) ) {
3417			method.call( value, resolve, reject );
3418
3419		// Other non-thenables
3420		} else {
3421
3422			// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
3423			// * false: [ value ].slice( 0 ) => resolve( value )
3424			// * true: [ value ].slice( 1 ) => resolve()
3425			resolve.apply( undefined, [ value ].slice( noValue ) );
3426		}
3427
3428	// For Promises/A+, convert exceptions into rejections
3429	// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
3430	// Deferred#then to conditionally suppress rejection.
3431	} catch ( value ) {
3432
3433		// Support: Android 4.0 only
3434		// Strict mode functions invoked without .call/.apply get global-object context
3435		reject.apply( undefined, [ value ] );
3436	}
3437}
3438
3439jQuery.extend( {
3440
3441	Deferred: function( func ) {
3442		var tuples = [
3443
3444				// action, add listener, callbacks,
3445				// ... .then handlers, argument index, [final state]
3446				[ "notify", "progress", jQuery.Callbacks( "memory" ),
3447					jQuery.Callbacks( "memory" ), 2 ],
3448				[ "resolve", "done", jQuery.Callbacks( "once memory" ),
3449					jQuery.Callbacks( "once memory" ), 0, "resolved" ],
3450				[ "reject", "fail", jQuery.Callbacks( "once memory" ),
3451					jQuery.Callbacks( "once memory" ), 1, "rejected" ]
3452			],
3453			state = "pending",
3454			promise = {
3455				state: function() {
3456					return state;
3457				},
3458				always: function() {
3459					deferred.done( arguments ).fail( arguments );
3460					return this;
3461				},
3462				"catch": function( fn ) {
3463					return promise.then( null, fn );
3464				},
3465
3466				// Keep pipe for back-compat
3467				pipe: function( /* fnDone, fnFail, fnProgress */ ) {
3468					var fns = arguments;
3469
3470					return jQuery.Deferred( function( newDefer ) {
3471						jQuery.each( tuples, function( _i, tuple ) {
3472
3473							// Map tuples (progress, done, fail) to arguments (done, fail, progress)
3474							var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
3475
3476							// deferred.progress(function() { bind to newDefer or newDefer.notify })
3477							// deferred.done(function() { bind to newDefer or newDefer.resolve })
3478							// deferred.fail(function() { bind to newDefer or newDefer.reject })
3479							deferred[ tuple[ 1 ] ]( function() {
3480								var returned = fn && fn.apply( this, arguments );
3481								if ( returned && isFunction( returned.promise ) ) {
3482									returned.promise()
3483										.progress( newDefer.notify )
3484										.done( newDefer.resolve )
3485										.fail( newDefer.reject );
3486								} else {
3487									newDefer[ tuple[ 0 ] + "With" ](
3488										this,
3489										fn ? [ returned ] : arguments
3490									);
3491								}
3492							} );
3493						} );
3494						fns = null;
3495					} ).promise();
3496				},
3497				then: function( onFulfilled, onRejected, onProgress ) {
3498					var maxDepth = 0;
3499					function resolve( depth, deferred, handler, special ) {
3500						return function() {
3501							var that = this,
3502								args = arguments,
3503								mightThrow = function() {
3504									var returned, then;
3505
3506									// Support: Promises/A+ section 2.3.3.3.3
3507									// https://promisesaplus.com/#point-59
3508									// Ignore double-resolution attempts
3509									if ( depth < maxDepth ) {
3510										return;
3511									}
3512
3513									returned = handler.apply( that, args );
3514
3515									// Support: Promises/A+ section 2.3.1
3516									// https://promisesaplus.com/#point-48
3517									if ( returned === deferred.promise() ) {
3518										throw new TypeError( "Thenable self-resolution" );
3519									}
3520
3521									// Support: Promises/A+ sections 2.3.3.1, 3.5
3522									// https://promisesaplus.com/#point-54
3523									// https://promisesaplus.com/#point-75
3524									// Retrieve `then` only once
3525									then = returned &&
3526
3527										// Support: Promises/A+ section 2.3.4
3528										// https://promisesaplus.com/#point-64
3529										// Only check objects and functions for thenability
3530										( typeof returned === "object" ||
3531											typeof returned === "function" ) &&
3532										returned.then;
3533
3534									// Handle a returned thenable
3535									if ( isFunction( then ) ) {
3536
3537										// Special processors (notify) just wait for resolution
3538										if ( special ) {
3539											then.call(
3540												returned,
3541												resolve( maxDepth, deferred, Identity, special ),
3542												resolve( maxDepth, deferred, Thrower, special )
3543											);
3544
3545										// Normal processors (resolve) also hook into progress
3546										} else {
3547
3548											// ...and disregard older resolution values
3549											maxDepth++;
3550
3551											then.call(
3552												returned,
3553												resolve( maxDepth, deferred, Identity, special ),
3554												resolve( maxDepth, deferred, Thrower, special ),
3555												resolve( maxDepth, deferred, Identity,
3556													deferred.notifyWith )
3557											);
3558										}
3559
3560									// Handle all other returned values
3561									} else {
3562
3563										// Only substitute handlers pass on context
3564										// and multiple values (non-spec behavior)
3565										if ( handler !== Identity ) {
3566											that = undefined;
3567											args = [ returned ];
3568										}
3569
3570										// Process the value(s)
3571										// Default process is resolve
3572										( special || deferred.resolveWith )( that, args );
3573									}
3574								},
3575
3576								// Only normal processors (resolve) catch and reject exceptions
3577								process = special ?
3578									mightThrow :
3579									function() {
3580										try {
3581											mightThrow();
3582										} catch ( e ) {
3583
3584											if ( jQuery.Deferred.exceptionHook ) {
3585												jQuery.Deferred.exceptionHook( e,
3586													process.error );
3587											}
3588
3589											// Support: Promises/A+ section 2.3.3.3.4.1
3590											// https://promisesaplus.com/#point-61
3591											// Ignore post-resolution exceptions
3592											if ( depth + 1 >= maxDepth ) {
3593
3594												// Only substitute handlers pass on context
3595												// and multiple values (non-spec behavior)
3596												if ( handler !== Thrower ) {
3597													that = undefined;
3598													args = [ e ];
3599												}
3600
3601												deferred.rejectWith( that, args );
3602											}
3603										}
3604									};
3605
3606							// Support: Promises/A+ section 2.3.3.3.1
3607							// https://promisesaplus.com/#point-57
3608							// Re-resolve promises immediately to dodge false rejection from
3609							// subsequent errors
3610							if ( depth ) {
3611								process();
3612							} else {
3613
3614								// Call an optional hook to record the error, in case of exception
3615								// since it's otherwise lost when execution goes async
3616								if ( jQuery.Deferred.getErrorHook ) {
3617									process.error = jQuery.Deferred.getErrorHook();
3618
3619								// The deprecated alias of the above. While the name suggests
3620								// returning the stack, not an error instance, jQuery just passes
3621								// it directly to `console.warn` so both will work; an instance
3622								// just better cooperates with source maps.
3623								} else if ( jQuery.Deferred.getStackHook ) {
3624									process.error = jQuery.Deferred.getStackHook();
3625								}
3626								window.setTimeout( process );
3627							}
3628						};
3629					}
3630
3631					return jQuery.Deferred( function( newDefer ) {
3632
3633						// progress_handlers.add( ... )
3634						tuples[ 0 ][ 3 ].add(
3635							resolve(
3636								0,
3637								newDefer,
3638								isFunction( onProgress ) ?
3639									onProgress :
3640									Identity,
3641								newDefer.notifyWith
3642							)
3643						);
3644
3645						// fulfilled_handlers.add( ... )
3646						tuples[ 1 ][ 3 ].add(
3647							resolve(
3648								0,
3649								newDefer,
3650								isFunction( onFulfilled ) ?
3651									onFulfilled :
3652									Identity
3653							)
3654						);
3655
3656						// rejected_handlers.add( ... )
3657						tuples[ 2 ][ 3 ].add(
3658							resolve(
3659								0,
3660								newDefer,
3661								isFunction( onRejected ) ?
3662									onRejected :
3663									Thrower
3664							)
3665						);
3666					} ).promise();
3667				},
3668
3669				// Get a promise for this deferred
3670				// If obj is provided, the promise aspect is added to the object
3671				promise: function( obj ) {
3672					return obj != null ? jQuery.extend( obj, promise ) : promise;
3673				}
3674			},
3675			deferred = {};
3676
3677		// Add list-specific methods
3678		jQuery.each( tuples, function( i, tuple ) {
3679			var list = tuple[ 2 ],
3680				stateString = tuple[ 5 ];
3681
3682			// promise.progress = list.add
3683			// promise.done = list.add
3684			// promise.fail = list.add
3685			promise[ tuple[ 1 ] ] = list.add;
3686
3687			// Handle state
3688			if ( stateString ) {
3689				list.add(
3690					function() {
3691
3692						// state = "resolved" (i.e., fulfilled)
3693						// state = "rejected"
3694						state = stateString;
3695					},
3696
3697					// rejected_callbacks.disable
3698					// fulfilled_callbacks.disable
3699					tuples[ 3 - i ][ 2 ].disable,
3700
3701					// rejected_handlers.disable
3702					// fulfilled_handlers.disable
3703					tuples[ 3 - i ][ 3 ].disable,
3704
3705					// progress_callbacks.lock
3706					tuples[ 0 ][ 2 ].lock,
3707
3708					// progress_handlers.lock
3709					tuples[ 0 ][ 3 ].lock
3710				);
3711			}
3712
3713			// progress_handlers.fire
3714			// fulfilled_handlers.fire
3715			// rejected_handlers.fire
3716			list.add( tuple[ 3 ].fire );
3717
3718			// deferred.notify = function() { deferred.notifyWith(...) }
3719			// deferred.resolve = function() { deferred.resolveWith(...) }
3720			// deferred.reject = function() { deferred.rejectWith(...) }
3721			deferred[ tuple[ 0 ] ] = function() {
3722				deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
3723				return this;
3724			};
3725
3726			// deferred.notifyWith = list.fireWith
3727			// deferred.resolveWith = list.fireWith
3728			// deferred.rejectWith = list.fireWith
3729			deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
3730		} );
3731
3732		// Make the deferred a promise
3733		promise.promise( deferred );
3734
3735		// Call given func if any
3736		if ( func ) {
3737			func.call( deferred, deferred );
3738		}
3739
3740		// All done!
3741		return deferred;
3742	},
3743
3744	// Deferred helper
3745	when: function( singleValue ) {
3746		var
3747
3748			// count of uncompleted subordinates
3749			remaining = arguments.length,
3750
3751			// count of unprocessed arguments
3752			i = remaining,
3753
3754			// subordinate fulfillment data
3755			resolveContexts = Array( i ),
3756			resolveValues = slice.call( arguments ),
3757
3758			// the primary Deferred
3759			primary = jQuery.Deferred(),
3760
3761			// subordinate callback factory
3762			updateFunc = function( i ) {
3763				return function( value ) {
3764					resolveContexts[ i ] = this;
3765					resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
3766					if ( !( --remaining ) ) {
3767						primary.resolveWith( resolveContexts, resolveValues );
3768					}
3769				};
3770			};
3771
3772		// Single- and empty arguments are adopted like Promise.resolve
3773		if ( remaining <= 1 ) {
3774			adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,
3775				!remaining );
3776
3777			// Use .then() to unwrap secondary thenables (cf. gh-3000)
3778			if ( primary.state() === "pending" ||
3779				isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
3780
3781				return primary.then();
3782			}
3783		}
3784
3785		// Multiple arguments are aggregated like Promise.all array elements
3786		while ( i-- ) {
3787			adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );
3788		}
3789
3790		return primary.promise();
3791	}
3792} );
3793
3794
3795// These usually indicate a programmer mistake during development,
3796// warn about them ASAP rather than swallowing them by default.
3797var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
3798
3799// If `jQuery.Deferred.getErrorHook` is defined, `asyncError` is an error
3800// captured before the async barrier to get the original error cause
3801// which may otherwise be hidden.
3802jQuery.Deferred.exceptionHook = function( error, asyncError ) {
3803
3804	// Support: IE 8 - 9 only
3805	// Console exists when dev tools are open, which can happen at any time
3806	if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
3807		window.console.warn( "jQuery.Deferred exception: " + error.message,
3808			error.stack, asyncError );
3809	}
3810};
3811
3812
3813
3814
3815jQuery.readyException = function( error ) {
3816	window.setTimeout( function() {
3817		throw error;
3818	} );
3819};
3820
3821
3822
3823
3824// The deferred used on DOM ready
3825var readyList = jQuery.Deferred();
3826
3827jQuery.fn.ready = function( fn ) {
3828
3829	readyList
3830		.then( fn )
3831
3832		// Wrap jQuery.readyException in a function so that the lookup
3833		// happens at the time of error handling instead of callback
3834		// registration.
3835		.catch( function( error ) {
3836			jQuery.readyException( error );
3837		} );
3838
3839	return this;
3840};
3841
3842jQuery.extend( {
3843
3844	// Is the DOM ready to be used? Set to true once it occurs.
3845	isReady: false,
3846
3847	// A counter to track how many items to wait for before
3848	// the ready event fires. See trac-6781
3849	readyWait: 1,
3850
3851	// Handle when the DOM is ready
3852	ready: function( wait ) {
3853
3854		// Abort if there are pending holds or we're already ready
3855		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
3856			return;
3857		}
3858
3859		// Remember that the DOM is ready
3860		jQuery.isReady = true;
3861
3862		// If a normal DOM Ready event fired, decrement, and wait if need be
3863		if ( wait !== true && --jQuery.readyWait > 0 ) {
3864			return;
3865		}
3866
3867		// If there are functions bound, to execute
3868		readyList.resolveWith( document, [ jQuery ] );
3869	}
3870} );
3871
3872jQuery.ready.then = readyList.then;
3873
3874// The ready event handler and self cleanup method
3875function completed() {
3876	document.removeEventListener( "DOMContentLoaded", completed );
3877	window.removeEventListener( "load", completed );
3878	jQuery.ready();
3879}
3880
3881// Catch cases where $(document).ready() is called
3882// after the browser event has already occurred.
3883// Support: IE <=9 - 10 only
3884// Older IE sometimes signals "interactive" too soon
3885if ( document.readyState === "complete" ||
3886	( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
3887
3888	// Handle it asynchronously to allow scripts the opportunity to delay ready
3889	window.setTimeout( jQuery.ready );
3890
3891} else {
3892
3893	// Use the handy event callback
3894	document.addEventListener( "DOMContentLoaded", completed );
3895
3896	// A fallback to window.onload, that will always work
3897	window.addEventListener( "load", completed );
3898}
3899
3900
3901
3902
3903// Multifunctional method to get and set values of a collection
3904// The value/s can optionally be executed if it's a function
3905var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
3906	var i = 0,
3907		len = elems.length,
3908		bulk = key == null;
3909
3910	// Sets many values
3911	if ( toType( key ) === "object" ) {
3912		chainable = true;
3913		for ( i in key ) {
3914			access( elems, fn, i, key[ i ], true, emptyGet, raw );
3915		}
3916
3917	// Sets one value
3918	} else if ( value !== undefined ) {
3919		chainable = true;
3920
3921		if ( !isFunction( value ) ) {
3922			raw = true;
3923		}
3924
3925		if ( bulk ) {
3926
3927			// Bulk operations run against the entire set
3928			if ( raw ) {
3929				fn.call( elems, value );
3930				fn = null;
3931
3932			// ...except when executing function values
3933			} else {
3934				bulk = fn;
3935				fn = function( elem, _key, value ) {
3936					return bulk.call( jQuery( elem ), value );
3937				};
3938			}
3939		}
3940
3941		if ( fn ) {
3942			for ( ; i < len; i++ ) {
3943				fn(
3944					elems[ i ], key, raw ?
3945						value :
3946						value.call( elems[ i ], i, fn( elems[ i ], key ) )
3947				);
3948			}
3949		}
3950	}
3951
3952	if ( chainable ) {
3953		return elems;
3954	}
3955
3956	// Gets
3957	if ( bulk ) {
3958		return fn.call( elems );
3959	}
3960
3961	return len ? fn( elems[ 0 ], key ) : emptyGet;
3962};
3963
3964
3965// Matches dashed string for camelizing
3966var rmsPrefix = /^-ms-/,
3967	rdashAlpha = /-([a-z])/g;
3968
3969// Used by camelCase as callback to replace()
3970function fcamelCase( _all, letter ) {
3971	return letter.toUpperCase();
3972}
3973
3974// Convert dashed to camelCase; used by the css and data modules
3975// Support: IE <=9 - 11, Edge 12 - 15
3976// Microsoft forgot to hump their vendor prefix (trac-9572)
3977function camelCase( string ) {
3978	return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
3979}
3980var acceptData = function( owner ) {
3981
3982	// Accepts only:
3983	//  - Node
3984	//    - Node.ELEMENT_NODE
3985	//    - Node.DOCUMENT_NODE
3986	//  - Object
3987	//    - Any
3988	return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
3989};
3990
3991
3992
3993
3994function Data() {
3995	this.expando = jQuery.expando + Data.uid++;
3996}
3997
3998Data.uid = 1;
3999
4000Data.prototype = {
4001
4002	cache: function( owner ) {
4003
4004		// Check if the owner object already has a cache
4005		var value = owner[ this.expando ];
4006
4007		// If not, create one
4008		if ( !value ) {
4009			value = {};
4010
4011			// We can accept data for non-element nodes in modern browsers,
4012			// but we should not, see trac-8335.
4013			// Always return an empty object.
4014			if ( acceptData( owner ) ) {
4015
4016				// If it is a node unlikely to be stringify-ed or looped over
4017				// use plain assignment
4018				if ( owner.nodeType ) {
4019					owner[ this.expando ] = value;
4020
4021				// Otherwise secure it in a non-enumerable property
4022				// configurable must be true to allow the property to be
4023				// deleted when data is removed
4024				} else {
4025					Object.defineProperty( owner, this.expando, {
4026						value: value,
4027						configurable: true
4028					} );
4029				}
4030			}
4031		}
4032
4033		return value;
4034	},
4035	set: function( owner, data, value ) {
4036		var prop,
4037			cache = this.cache( owner );
4038
4039		// Handle: [ owner, key, value ] args
4040		// Always use camelCase key (gh-2257)
4041		if ( typeof data === "string" ) {
4042			cache[ camelCase( data ) ] = value;
4043
4044		// Handle: [ owner, { properties } ] args
4045		} else {
4046
4047			// Copy the properties one-by-one to the cache object
4048			for ( prop in data ) {
4049				cache[ camelCase( prop ) ] = data[ prop ];
4050			}
4051		}
4052		return cache;
4053	},
4054	get: function( owner, key ) {
4055		return key === undefined ?
4056			this.cache( owner ) :
4057
4058			// Always use camelCase key (gh-2257)
4059			owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];
4060	},
4061	access: function( owner, key, value ) {
4062
4063		// In cases where either:
4064		//
4065		//   1. No key was specified
4066		//   2. A string key was specified, but no value provided
4067		//
4068		// Take the "read" path and allow the get method to determine
4069		// which value to return, respectively either:
4070		//
4071		//   1. The entire cache object
4072		//   2. The data stored at the key
4073		//
4074		if ( key === undefined ||
4075				( ( key && typeof key === "string" ) && value === undefined ) ) {
4076
4077			return this.get( owner, key );
4078		}
4079
4080		// When the key is not a string, or both a key and value
4081		// are specified, set or extend (existing objects) with either:
4082		//
4083		//   1. An object of properties
4084		//   2. A key and value
4085		//
4086		this.set( owner, key, value );
4087
4088		// Since the "set" path can have two possible entry points
4089		// return the expected data based on which path was taken[*]
4090		return value !== undefined ? value : key;
4091	},
4092	remove: function( owner, key ) {
4093		var i,
4094			cache = owner[ this.expando ];
4095
4096		if ( cache === undefined ) {
4097			return;
4098		}
4099
4100		if ( key !== undefined ) {
4101
4102			// Support array or space separated string of keys
4103			if ( Array.isArray( key ) ) {
4104
4105				// If key is an array of keys...
4106				// We always set camelCase keys, so remove that.
4107				key = key.map( camelCase );
4108			} else {
4109				key = camelCase( key );
4110
4111				// If a key with the spaces exists, use it.
4112				// Otherwise, create an array by matching non-whitespace
4113				key = key in cache ?
4114					[ key ] :
4115					( key.match( rnothtmlwhite ) || [] );
4116			}
4117
4118			i = key.length;
4119
4120			while ( i-- ) {
4121				delete cache[ key[ i ] ];
4122			}
4123		}
4124
4125		// Remove the expando if there's no more data
4126		if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
4127
4128			// Support: Chrome <=35 - 45
4129			// Webkit & Blink performance suffers when deleting properties
4130			// from DOM nodes, so set to undefined instead
4131			// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
4132			if ( owner.nodeType ) {
4133				owner[ this.expando ] = undefined;
4134			} else {
4135				delete owner[ this.expando ];
4136			}
4137		}
4138	},
4139	hasData: function( owner ) {
4140		var cache = owner[ this.expando ];
4141		return cache !== undefined && !jQuery.isEmptyObject( cache );
4142	}
4143};
4144var dataPriv = new Data();
4145
4146var dataUser = new Data();
4147
4148
4149
4150//	Implementation Summary
4151//
4152//	1. Enforce API surface and semantic compatibility with 1.9.x branch
4153//	2. Improve the module's maintainability by reducing the storage
4154//		paths to a single mechanism.
4155//	3. Use the same single mechanism to support "private" and "user" data.
4156//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
4157//	5. Avoid exposing implementation details on user objects (eg. expando properties)
4158//	6. Provide a clear path for implementation upgrade to WeakMap in 2014
4159
4160var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
4161	rmultiDash = /[A-Z]/g;
4162
4163function getData( data ) {
4164	if ( data === "true" ) {
4165		return true;
4166	}
4167
4168	if ( data === "false" ) {
4169		return false;
4170	}
4171
4172	if ( data === "null" ) {
4173		return null;
4174	}
4175
4176	// Only convert to a number if it doesn't change the string
4177	if ( data === +data + "" ) {
4178		return +data;
4179	}
4180
4181	if ( rbrace.test( data ) ) {
4182		return JSON.parse( data );
4183	}
4184
4185	return data;
4186}
4187
4188function dataAttr( elem, key, data ) {
4189	var name;
4190
4191	// If nothing was found internally, try to fetch any
4192	// data from the HTML5 data-* attribute
4193	if ( data === undefined && elem.nodeType === 1 ) {
4194		name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
4195		data = elem.getAttribute( name );
4196
4197		if ( typeof data === "string" ) {
4198			try {
4199				data = getData( data );
4200			} catch ( e ) {}
4201
4202			// Make sure we set the data so it isn't changed later
4203			dataUser.set( elem, key, data );
4204		} else {
4205			data = undefined;
4206		}
4207	}
4208	return data;
4209}
4210
4211jQuery.extend( {
4212	hasData: function( elem ) {
4213		return dataUser.hasData( elem ) || dataPriv.hasData( elem );
4214	},
4215
4216	data: function( elem, name, data ) {
4217		return dataUser.access( elem, name, data );
4218	},
4219
4220	removeData: function( elem, name ) {
4221		dataUser.remove( elem, name );
4222	},
4223
4224	// TODO: Now that all calls to _data and _removeData have been replaced
4225	// with direct calls to dataPriv methods, these can be deprecated.
4226	_data: function( elem, name, data ) {
4227		return dataPriv.access( elem, name, data );
4228	},
4229
4230	_removeData: function( elem, name ) {
4231		dataPriv.remove( elem, name );
4232	}
4233} );
4234
4235jQuery.fn.extend( {
4236	data: function( key, value ) {
4237		var i, name, data,
4238			elem = this[ 0 ],
4239			attrs = elem && elem.attributes;
4240
4241		// Gets all values
4242		if ( key === undefined ) {
4243			if ( this.length ) {
4244				data = dataUser.get( elem );
4245
4246				if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
4247					i = attrs.length;
4248					while ( i-- ) {
4249
4250						// Support: IE 11 only
4251						// The attrs elements can be null (trac-14894)
4252						if ( attrs[ i ] ) {
4253							name = attrs[ i ].name;
4254							if ( name.indexOf( "data-" ) === 0 ) {
4255								name = camelCase( name.slice( 5 ) );
4256								dataAttr( elem, name, data[ name ] );
4257							}
4258						}
4259					}
4260					dataPriv.set( elem, "hasDataAttrs", true );
4261				}
4262			}
4263
4264			return data;
4265		}
4266
4267		// Sets multiple values
4268		if ( typeof key === "object" ) {
4269			return this.each( function() {
4270				dataUser.set( this, key );
4271			} );
4272		}
4273
4274		return access( this, function( value ) {
4275			var data;
4276
4277			// The calling jQuery object (element matches) is not empty
4278			// (and therefore has an element appears at this[ 0 ]) and the
4279			// `value` parameter was not undefined. An empty jQuery object
4280			// will result in `undefined` for elem = this[ 0 ] which will
4281			// throw an exception if an attempt to read a data cache is made.
4282			if ( elem && value === undefined ) {
4283
4284				// Attempt to get data from the cache
4285				// The key will always be camelCased in Data
4286				data = dataUser.get( elem, key );
4287				if ( data !== undefined ) {
4288					return data;
4289				}
4290
4291				// Attempt to "discover" the data in
4292				// HTML5 custom data-* attrs
4293				data = dataAttr( elem, key );
4294				if ( data !== undefined ) {
4295					return data;
4296				}
4297
4298				// We tried really hard, but the data doesn't exist.
4299				return;
4300			}
4301
4302			// Set the data...
4303			this.each( function() {
4304
4305				// We always store the camelCased key
4306				dataUser.set( this, key, value );
4307			} );
4308		}, null, value, arguments.length > 1, null, true );
4309	},
4310
4311	removeData: function( key ) {
4312		return this.each( function() {
4313			dataUser.remove( this, key );
4314		} );
4315	}
4316} );
4317
4318
4319jQuery.extend( {
4320	queue: function( elem, type, data ) {
4321		var queue;
4322
4323		if ( elem ) {
4324			type = ( type || "fx" ) + "queue";
4325			queue = dataPriv.get( elem, type );
4326
4327			// Speed up dequeue by getting out quickly if this is just a lookup
4328			if ( data ) {
4329				if ( !queue || Array.isArray( data ) ) {
4330					queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
4331				} else {
4332					queue.push( data );
4333				}
4334			}
4335			return queue || [];
4336		}
4337	},
4338
4339	dequeue: function( elem, type ) {
4340		type = type || "fx";
4341
4342		var queue = jQuery.queue( elem, type ),
4343			startLength = queue.length,
4344			fn = queue.shift(),
4345			hooks = jQuery._queueHooks( elem, type ),
4346			next = function() {
4347				jQuery.dequeue( elem, type );
4348			};
4349
4350		// If the fx queue is dequeued, always remove the progress sentinel
4351		if ( fn === "inprogress" ) {
4352			fn = queue.shift();
4353			startLength--;
4354		}
4355
4356		if ( fn ) {
4357
4358			// Add a progress sentinel to prevent the fx queue from being
4359			// automatically dequeued
4360			if ( type === "fx" ) {
4361				queue.unshift( "inprogress" );
4362			}
4363
4364			// Clear up the last queue stop function
4365			delete hooks.stop;
4366			fn.call( elem, next, hooks );
4367		}
4368
4369		if ( !startLength && hooks ) {
4370			hooks.empty.fire();
4371		}
4372	},
4373
4374	// Not public - generate a queueHooks object, or return the current one
4375	_queueHooks: function( elem, type ) {
4376		var key = type + "queueHooks";
4377		return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
4378			empty: jQuery.Callbacks( "once memory" ).add( function() {
4379				dataPriv.remove( elem, [ type + "queue", key ] );
4380			} )
4381		} );
4382	}
4383} );
4384
4385jQuery.fn.extend( {
4386	queue: function( type, data ) {
4387		var setter = 2;
4388
4389		if ( typeof type !== "string" ) {
4390			data = type;
4391			type = "fx";
4392			setter--;
4393		}
4394
4395		if ( arguments.length < setter ) {
4396			return jQuery.queue( this[ 0 ], type );
4397		}
4398
4399		return data === undefined ?
4400			this :
4401			this.each( function() {
4402				var queue = jQuery.queue( this, type, data );
4403
4404				// Ensure a hooks for this queue
4405				jQuery._queueHooks( this, type );
4406
4407				if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
4408					jQuery.dequeue( this, type );
4409				}
4410			} );
4411	},
4412	dequeue: function( type ) {
4413		return this.each( function() {
4414			jQuery.dequeue( this, type );
4415		} );
4416	},
4417	clearQueue: function( type ) {
4418		return this.queue( type || "fx", [] );
4419	},
4420
4421	// Get a promise resolved when queues of a certain type
4422	// are emptied (fx is the type by default)
4423	promise: function( type, obj ) {
4424		var tmp,
4425			count = 1,
4426			defer = jQuery.Deferred(),
4427			elements = this,
4428			i = this.length,
4429			resolve = function() {
4430				if ( !( --count ) ) {
4431					defer.resolveWith( elements, [ elements ] );
4432				}
4433			};
4434
4435		if ( typeof type !== "string" ) {
4436			obj = type;
4437			type = undefined;
4438		}
4439		type = type || "fx";
4440
4441		while ( i-- ) {
4442			tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
4443			if ( tmp && tmp.empty ) {
4444				count++;
4445				tmp.empty.add( resolve );
4446			}
4447		}
4448		resolve();
4449		return defer.promise( obj );
4450	}
4451} );
4452var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
4453
4454var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
4455
4456
4457var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
4458
4459var documentElement = document.documentElement;
4460
4461
4462
4463	var isAttached = function( elem ) {
4464			return jQuery.contains( elem.ownerDocument, elem );
4465		},
4466		composed = { composed: true };
4467
4468	// Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only
4469	// Check attachment across shadow DOM boundaries when possible (gh-3504)
4470	// Support: iOS 10.0-10.2 only
4471	// Early iOS 10 versions support `attachShadow` but not `getRootNode`,
4472	// leading to errors. We need to check for `getRootNode`.
4473	if ( documentElement.getRootNode ) {
4474		isAttached = function( elem ) {
4475			return jQuery.contains( elem.ownerDocument, elem ) ||
4476				elem.getRootNode( composed ) === elem.ownerDocument;
4477		};
4478	}
4479var isHiddenWithinTree = function( elem, el ) {
4480
4481		// isHiddenWithinTree might be called from jQuery#filter function;
4482		// in that case, element will be second argument
4483		elem = el || elem;
4484
4485		// Inline style trumps all
4486		return elem.style.display === "none" ||
4487			elem.style.display === "" &&
4488
4489			// Otherwise, check computed style
4490			// Support: Firefox <=43 - 45
4491			// Disconnected elements can have computed display: none, so first confirm that elem is
4492			// in the document.
4493			isAttached( elem ) &&
4494
4495			jQuery.css( elem, "display" ) === "none";
4496	};
4497
4498
4499
4500function adjustCSS( elem, prop, valueParts, tween ) {
4501	var adjusted, scale,
4502		maxIterations = 20,
4503		currentValue = tween ?
4504			function() {
4505				return tween.cur();
4506			} :
4507			function() {
4508				return jQuery.css( elem, prop, "" );
4509			},
4510		initial = currentValue(),
4511		unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
4512
4513		// Starting value computation is required for potential unit mismatches
4514		initialInUnit = elem.nodeType &&
4515			( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
4516			rcssNum.exec( jQuery.css( elem, prop ) );
4517
4518	if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
4519
4520		// Support: Firefox <=54
4521		// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
4522		initial = initial / 2;
4523
4524		// Trust units reported by jQuery.css
4525		unit = unit || initialInUnit[ 3 ];
4526
4527		// Iteratively approximate from a nonzero starting point
4528		initialInUnit = +initial || 1;
4529
4530		while ( maxIterations-- ) {
4531
4532			// Evaluate and update our best guess (doubling guesses that zero out).
4533			// Finish if the scale equals or crosses 1 (making the old*new product non-positive).
4534			jQuery.style( elem, prop, initialInUnit + unit );
4535			if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {
4536				maxIterations = 0;
4537			}
4538			initialInUnit = initialInUnit / scale;
4539
4540		}
4541
4542		initialInUnit = initialInUnit * 2;
4543		jQuery.style( elem, prop, initialInUnit + unit );
4544
4545		// Make sure we update the tween properties later on
4546		valueParts = valueParts || [];
4547	}
4548
4549	if ( valueParts ) {
4550		initialInUnit = +initialInUnit || +initial || 0;
4551
4552		// Apply relative offset (+=/-=) if specified
4553		adjusted = valueParts[ 1 ] ?
4554			initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
4555			+valueParts[ 2 ];
4556		if ( tween ) {
4557			tween.unit = unit;
4558			tween.start = initialInUnit;
4559			tween.end = adjusted;
4560		}
4561	}
4562	return adjusted;
4563}
4564
4565
4566var defaultDisplayMap = {};
4567
4568function getDefaultDisplay( elem ) {
4569	var temp,
4570		doc = elem.ownerDocument,
4571		nodeName = elem.nodeName,
4572		display = defaultDisplayMap[ nodeName ];
4573
4574	if ( display ) {
4575		return display;
4576	}
4577
4578	temp = doc.body.appendChild( doc.createElement( nodeName ) );
4579	display = jQuery.css( temp, "display" );
4580
4581	temp.parentNode.removeChild( temp );
4582
4583	if ( display === "none" ) {
4584		display = "block";
4585	}
4586	defaultDisplayMap[ nodeName ] = display;
4587
4588	return display;
4589}
4590
4591function showHide( elements, show ) {
4592	var display, elem,
4593		values = [],
4594		index = 0,
4595		length = elements.length;
4596
4597	// Determine new display value for elements that need to change
4598	for ( ; index < length; index++ ) {
4599		elem = elements[ index ];
4600		if ( !elem.style ) {
4601			continue;
4602		}
4603
4604		display = elem.style.display;
4605		if ( show ) {
4606
4607			// Since we force visibility upon cascade-hidden elements, an immediate (and slow)
4608			// check is required in this first loop unless we have a nonempty display value (either
4609			// inline or about-to-be-restored)
4610			if ( display === "none" ) {
4611				values[ index ] = dataPriv.get( elem, "display" ) || null;
4612				if ( !values[ index ] ) {
4613					elem.style.display = "";
4614				}
4615			}
4616			if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
4617				values[ index ] = getDefaultDisplay( elem );
4618			}
4619		} else {
4620			if ( display !== "none" ) {
4621				values[ index ] = "none";
4622
4623				// Remember what we're overwriting
4624				dataPriv.set( elem, "display", display );
4625			}
4626		}
4627	}
4628
4629	// Set the display of the elements in a second loop to avoid constant reflow
4630	for ( index = 0; index < length; index++ ) {
4631		if ( values[ index ] != null ) {
4632			elements[ index ].style.display = values[ index ];
4633		}
4634	}
4635
4636	return elements;
4637}
4638
4639jQuery.fn.extend( {
4640	show: function() {
4641		return showHide( this, true );
4642	},
4643	hide: function() {
4644		return showHide( this );
4645	},
4646	toggle: function( state ) {
4647		if ( typeof state === "boolean" ) {
4648			return state ? this.show() : this.hide();
4649		}
4650
4651		return this.each( function() {
4652			if ( isHiddenWithinTree( this ) ) {
4653				jQuery( this ).show();
4654			} else {
4655				jQuery( this ).hide();
4656			}
4657		} );
4658	}
4659} );
4660var rcheckableType = ( /^(?:checkbox|radio)$/i );
4661
4662var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i );
4663
4664var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i );
4665
4666
4667
4668( function() {
4669	var fragment = document.createDocumentFragment(),
4670		div = fragment.appendChild( document.createElement( "div" ) ),
4671		input = document.createElement( "input" );
4672
4673	// Support: Android 4.0 - 4.3 only
4674	// Check state lost if the name is set (trac-11217)
4675	// Support: Windows Web Apps (WWA)
4676	// `name` and `type` must use .setAttribute for WWA (trac-14901)
4677	input.setAttribute( "type", "radio" );
4678	input.setAttribute( "checked", "checked" );
4679	input.setAttribute( "name", "t" );
4680
4681	div.appendChild( input );
4682
4683	// Support: Android <=4.1 only
4684	// Older WebKit doesn't clone checked state correctly in fragments
4685	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
4686
4687	// Support: IE <=11 only
4688	// Make sure textarea (and checkbox) defaultValue is properly cloned
4689	div.innerHTML = "<textarea>x</textarea>";
4690	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
4691
4692	// Support: IE <=9 only
4693	// IE <=9 replaces <option> tags with their contents when inserted outside of
4694	// the select element.
4695	div.innerHTML = "<option></option>";
4696	support.option = !!div.lastChild;
4697} )();
4698
4699
4700// We have to close these tags to support XHTML (trac-13200)
4701var wrapMap = {
4702
4703	// XHTML parsers do not magically insert elements in the
4704	// same way that tag soup parsers do. So we cannot shorten
4705	// this by omitting <tbody> or other required elements.
4706	thead: [ 1, "<table>", "</table>" ],
4707	col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
4708	tr: [ 2, "<table><tbody>", "</tbody></table>" ],
4709	td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
4710
4711	_default: [ 0, "", "" ]
4712};
4713
4714wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
4715wrapMap.th = wrapMap.td;
4716
4717// Support: IE <=9 only
4718if ( !support.option ) {
4719	wrapMap.optgroup = wrapMap.option = [ 1, "<select multiple='multiple'>", "</select>" ];
4720}
4721
4722
4723function getAll( context, tag ) {
4724
4725	// Support: IE <=9 - 11 only
4726	// Use typeof to avoid zero-argument method invocation on host objects (trac-15151)
4727	var ret;
4728
4729	if ( typeof context.getElementsByTagName !== "undefined" ) {
4730		ret = context.getElementsByTagName( tag || "*" );
4731
4732	} else if ( typeof context.querySelectorAll !== "undefined" ) {
4733		ret = context.querySelectorAll( tag || "*" );
4734
4735	} else {
4736		ret = [];
4737	}
4738
4739	if ( tag === undefined || tag && nodeName( context, tag ) ) {
4740		return jQuery.merge( [ context ], ret );
4741	}
4742
4743	return ret;
4744}
4745
4746
4747// Mark scripts as having already been evaluated
4748function setGlobalEval( elems, refElements ) {
4749	var i = 0,
4750		l = elems.length;
4751
4752	for ( ; i < l; i++ ) {
4753		dataPriv.set(
4754			elems[ i ],
4755			"globalEval",
4756			!refElements || dataPriv.get( refElements[ i ], "globalEval" )
4757		);
4758	}
4759}
4760
4761
4762var rhtml = /<|&#?\w+;/;
4763
4764function buildFragment( elems, context, scripts, selection, ignored ) {
4765	var elem, tmp, tag, wrap, attached, j,
4766		fragment = context.createDocumentFragment(),
4767		nodes = [],
4768		i = 0,
4769		l = elems.length;
4770
4771	for ( ; i < l; i++ ) {
4772		elem = elems[ i ];
4773
4774		if ( elem || elem === 0 ) {
4775
4776			// Add nodes directly
4777			if ( toType( elem ) === "object" ) {
4778
4779				// Support: Android <=4.0 only, PhantomJS 1 only
4780				// push.apply(_, arraylike) throws on ancient WebKit
4781				jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
4782
4783			// Convert non-html into a text node
4784			} else if ( !rhtml.test( elem ) ) {
4785				nodes.push( context.createTextNode( elem ) );
4786
4787			// Convert html into DOM nodes
4788			} else {
4789				tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
4790
4791				// Deserialize a standard representation
4792				tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
4793				wrap = wrapMap[ tag ] || wrapMap._default;
4794				tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
4795
4796				// Descend through wrappers to the right content
4797				j = wrap[ 0 ];
4798				while ( j-- ) {
4799					tmp = tmp.lastChild;
4800				}
4801
4802				// Support: Android <=4.0 only, PhantomJS 1 only
4803				// push.apply(_, arraylike) throws on ancient WebKit
4804				jQuery.merge( nodes, tmp.childNodes );
4805
4806				// Remember the top-level container
4807				tmp = fragment.firstChild;
4808
4809				// Ensure the created nodes are orphaned (trac-12392)
4810				tmp.textContent = "";
4811			}
4812		}
4813	}
4814
4815	// Remove wrapper from fragment
4816	fragment.textContent = "";
4817
4818	i = 0;
4819	while ( ( elem = nodes[ i++ ] ) ) {
4820
4821		// Skip elements already in the context collection (trac-4087)
4822		if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
4823			if ( ignored ) {
4824				ignored.push( elem );
4825			}
4826			continue;
4827		}
4828
4829		attached = isAttached( elem );
4830
4831		// Append to fragment
4832		tmp = getAll( fragment.appendChild( elem ), "script" );
4833
4834		// Preserve script evaluation history
4835		if ( attached ) {
4836			setGlobalEval( tmp );
4837		}
4838
4839		// Capture executables
4840		if ( scripts ) {
4841			j = 0;
4842			while ( ( elem = tmp[ j++ ] ) ) {
4843				if ( rscriptType.test( elem.type || "" ) ) {
4844					scripts.push( elem );
4845				}
4846			}
4847		}
4848	}
4849
4850	return fragment;
4851}
4852
4853
4854var rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
4855
4856function returnTrue() {
4857	return true;
4858}
4859
4860function returnFalse() {
4861	return false;
4862}
4863
4864function on( elem, types, selector, data, fn, one ) {
4865	var origFn, type;
4866
4867	// Types can be a map of types/handlers
4868	if ( typeof types === "object" ) {
4869
4870		// ( types-Object, selector, data )
4871		if ( typeof selector !== "string" ) {
4872
4873			// ( types-Object, data )
4874			data = data || selector;
4875			selector = undefined;
4876		}
4877		for ( type in types ) {
4878			on( elem, type, selector, data, types[ type ], one );
4879		}
4880		return elem;
4881	}
4882
4883	if ( data == null && fn == null ) {
4884
4885		// ( types, fn )
4886		fn = selector;
4887		data = selector = undefined;
4888	} else if ( fn == null ) {
4889		if ( typeof selector === "string" ) {
4890
4891			// ( types, selector, fn )
4892			fn = data;
4893			data = undefined;
4894		} else {
4895
4896			// ( types, data, fn )
4897			fn = data;
4898			data = selector;
4899			selector = undefined;
4900		}
4901	}
4902	if ( fn === false ) {
4903		fn = returnFalse;
4904	} else if ( !fn ) {
4905		return elem;
4906	}
4907
4908	if ( one === 1 ) {
4909		origFn = fn;
4910		fn = function( event ) {
4911
4912			// Can use an empty set, since event contains the info
4913			jQuery().off( event );
4914			return origFn.apply( this, arguments );
4915		};
4916
4917		// Use same guid so caller can remove using origFn
4918		fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
4919	}
4920	return elem.each( function() {
4921		jQuery.event.add( this, types, fn, data, selector );
4922	} );
4923}
4924
4925/*
4926 * Helper functions for managing events -- not part of the public interface.
4927 * Props to Dean Edwards' addEvent library for many of the ideas.
4928 */
4929jQuery.event = {
4930
4931	global: {},
4932
4933	add: function( elem, types, handler, data, selector ) {
4934
4935		var handleObjIn, eventHandle, tmp,
4936			events, t, handleObj,
4937			special, handlers, type, namespaces, origType,
4938			elemData = dataPriv.get( elem );
4939
4940		// Only attach events to objects that accept data
4941		if ( !acceptData( elem ) ) {
4942			return;
4943		}
4944
4945		// Caller can pass in an object of custom data in lieu of the handler
4946		if ( handler.handler ) {
4947			handleObjIn = handler;
4948			handler = handleObjIn.handler;
4949			selector = handleObjIn.selector;
4950		}
4951
4952		// Ensure that invalid selectors throw exceptions at attach time
4953		// Evaluate against documentElement in case elem is a non-element node (e.g., document)
4954		if ( selector ) {
4955			jQuery.find.matchesSelector( documentElement, selector );
4956		}
4957
4958		// Make sure that the handler has a unique ID, used to find/remove it later
4959		if ( !handler.guid ) {
4960			handler.guid = jQuery.guid++;
4961		}
4962
4963		// Init the element's event structure and main handler, if this is the first
4964		if ( !( events = elemData.events ) ) {
4965			events = elemData.events = Object.create( null );
4966		}
4967		if ( !( eventHandle = elemData.handle ) ) {
4968			eventHandle = elemData.handle = function( e ) {
4969
4970				// Discard the second event of a jQuery.event.trigger() and
4971				// when an event is called after a page has unloaded
4972				return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
4973					jQuery.event.dispatch.apply( elem, arguments ) : undefined;
4974			};
4975		}
4976
4977		// Handle multiple events separated by a space
4978		types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
4979		t = types.length;
4980		while ( t-- ) {
4981			tmp = rtypenamespace.exec( types[ t ] ) || [];
4982			type = origType = tmp[ 1 ];
4983			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
4984
4985			// There *must* be a type, no attaching namespace-only handlers
4986			if ( !type ) {
4987				continue;
4988			}
4989
4990			// If event changes its type, use the special event handlers for the changed type
4991			special = jQuery.event.special[ type ] || {};
4992
4993			// If selector defined, determine special event api type, otherwise given type
4994			type = ( selector ? special.delegateType : special.bindType ) || type;
4995
4996			// Update special based on newly reset type
4997			special = jQuery.event.special[ type ] || {};
4998
4999			// handleObj is passed to all event handlers
5000			handleObj = jQuery.extend( {
5001				type: type,
5002				origType: origType,
5003				data: data,
5004				handler: handler,
5005				guid: handler.guid,
5006				selector: selector,
5007				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
5008				namespace: namespaces.join( "." )
5009			}, handleObjIn );
5010
5011			// Init the event handler queue if we're the first
5012			if ( !( handlers = events[ type ] ) ) {
5013				handlers = events[ type ] = [];
5014				handlers.delegateCount = 0;
5015
5016				// Only use addEventListener if the special events handler returns false
5017				if ( !special.setup ||
5018					special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
5019
5020					if ( elem.addEventListener ) {
5021						elem.addEventListener( type, eventHandle );
5022					}
5023				}
5024			}
5025
5026			if ( special.add ) {
5027				special.add.call( elem, handleObj );
5028
5029				if ( !handleObj.handler.guid ) {
5030					handleObj.handler.guid = handler.guid;
5031				}
5032			}
5033
5034			// Add to the element's handler list, delegates in front
5035			if ( selector ) {
5036				handlers.splice( handlers.delegateCount++, 0, handleObj );
5037			} else {
5038				handlers.push( handleObj );
5039			}
5040
5041			// Keep track of which events have ever been used, for event optimization
5042			jQuery.event.global[ type ] = true;
5043		}
5044
5045	},
5046
5047	// Detach an event or set of events from an element
5048	remove: function( elem, types, handler, selector, mappedTypes ) {
5049
5050		var j, origCount, tmp,
5051			events, t, handleObj,
5052			special, handlers, type, namespaces, origType,
5053			elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
5054
5055		if ( !elemData || !( events = elemData.events ) ) {
5056			return;
5057		}
5058
5059		// Once for each type.namespace in types; type may be omitted
5060		types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
5061		t = types.length;
5062		while ( t-- ) {
5063			tmp = rtypenamespace.exec( types[ t ] ) || [];
5064			type = origType = tmp[ 1 ];
5065			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
5066
5067			// Unbind all events (on this namespace, if provided) for the element
5068			if ( !type ) {
5069				for ( type in events ) {
5070					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
5071				}
5072				continue;
5073			}
5074
5075			special = jQuery.event.special[ type ] || {};
5076			type = ( selector ? special.delegateType : special.bindType ) || type;
5077			handlers = events[ type ] || [];
5078			tmp = tmp[ 2 ] &&
5079				new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
5080
5081			// Remove matching events
5082			origCount = j = handlers.length;
5083			while ( j-- ) {
5084				handleObj = handlers[ j ];
5085
5086				if ( ( mappedTypes || origType === handleObj.origType ) &&
5087					( !handler || handler.guid === handleObj.guid ) &&
5088					( !tmp || tmp.test( handleObj.namespace ) ) &&
5089					( !selector || selector === handleObj.selector ||
5090						selector === "**" && handleObj.selector ) ) {
5091					handlers.splice( j, 1 );
5092
5093					if ( handleObj.selector ) {
5094						handlers.delegateCount--;
5095					}
5096					if ( special.remove ) {
5097						special.remove.call( elem, handleObj );
5098					}
5099				}
5100			}
5101
5102			// Remove generic event handler if we removed something and no more handlers exist
5103			// (avoids potential for endless recursion during removal of special event handlers)
5104			if ( origCount && !handlers.length ) {
5105				if ( !special.teardown ||
5106					special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
5107
5108					jQuery.removeEvent( elem, type, elemData.handle );
5109				}
5110
5111				delete events[ type ];
5112			}
5113		}
5114
5115		// Remove data and the expando if it's no longer used
5116		if ( jQuery.isEmptyObject( events ) ) {
5117			dataPriv.remove( elem, "handle events" );
5118		}
5119	},
5120
5121	dispatch: function( nativeEvent ) {
5122
5123		var i, j, ret, matched, handleObj, handlerQueue,
5124			args = new Array( arguments.length ),
5125
5126			// Make a writable jQuery.Event from the native event object
5127			event = jQuery.event.fix( nativeEvent ),
5128
5129			handlers = (
5130				dataPriv.get( this, "events" ) || Object.create( null )
5131			)[ event.type ] || [],
5132			special = jQuery.event.special[ event.type ] || {};
5133
5134		// Use the fix-ed jQuery.Event rather than the (read-only) native event
5135		args[ 0 ] = event;
5136
5137		for ( i = 1; i < arguments.length; i++ ) {
5138			args[ i ] = arguments[ i ];
5139		}
5140
5141		event.delegateTarget = this;
5142
5143		// Call the preDispatch hook for the mapped type, and let it bail if desired
5144		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
5145			return;
5146		}
5147
5148		// Determine handlers
5149		handlerQueue = jQuery.event.handlers.call( this, event, handlers );
5150
5151		// Run delegates first; they may want to stop propagation beneath us
5152		i = 0;
5153		while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
5154			event.currentTarget = matched.elem;
5155
5156			j = 0;
5157			while ( ( handleObj = matched.handlers[ j++ ] ) &&
5158				!event.isImmediatePropagationStopped() ) {
5159
5160				// If the event is namespaced, then each handler is only invoked if it is
5161				// specially universal or its namespaces are a superset of the event's.
5162				if ( !event.rnamespace || handleObj.namespace === false ||
5163					event.rnamespace.test( handleObj.namespace ) ) {
5164
5165					event.handleObj = handleObj;
5166					event.data = handleObj.data;
5167
5168					ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
5169						handleObj.handler ).apply( matched.elem, args );
5170
5171					if ( ret !== undefined ) {
5172						if ( ( event.result = ret ) === false ) {
5173							event.preventDefault();
5174							event.stopPropagation();
5175						}
5176					}
5177				}
5178			}
5179		}
5180
5181		// Call the postDispatch hook for the mapped type
5182		if ( special.postDispatch ) {
5183			special.postDispatch.call( this, event );
5184		}
5185
5186		return event.result;
5187	},
5188
5189	handlers: function( event, handlers ) {
5190		var i, handleObj, sel, matchedHandlers, matchedSelectors,
5191			handlerQueue = [],
5192			delegateCount = handlers.delegateCount,
5193			cur = event.target;
5194
5195		// Find delegate handlers
5196		if ( delegateCount &&
5197
5198			// Support: IE <=9
5199			// Black-hole SVG <use> instance trees (trac-13180)
5200			cur.nodeType &&
5201
5202			// Support: Firefox <=42
5203			// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
5204			// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
5205			// Support: IE 11 only
5206			// ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
5207			!( event.type === "click" && event.button >= 1 ) ) {
5208
5209			for ( ; cur !== this; cur = cur.parentNode || this ) {
5210
5211				// Don't check non-elements (trac-13208)
5212				// Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764)
5213				if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
5214					matchedHandlers = [];
5215					matchedSelectors = {};
5216					for ( i = 0; i < delegateCount; i++ ) {
5217						handleObj = handlers[ i ];
5218
5219						// Don't conflict with Object.prototype properties (trac-13203)
5220						sel = handleObj.selector + " ";
5221
5222						if ( matchedSelectors[ sel ] === undefined ) {
5223							matchedSelectors[ sel ] = handleObj.needsContext ?
5224								jQuery( sel, this ).index( cur ) > -1 :
5225								jQuery.find( sel, this, null, [ cur ] ).length;
5226						}
5227						if ( matchedSelectors[ sel ] ) {
5228							matchedHandlers.push( handleObj );
5229						}
5230					}
5231					if ( matchedHandlers.length ) {
5232						handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
5233					}
5234				}
5235			}
5236		}
5237
5238		// Add the remaining (directly-bound) handlers
5239		cur = this;
5240		if ( delegateCount < handlers.length ) {
5241			handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
5242		}
5243
5244		return handlerQueue;
5245	},
5246
5247	addProp: function( name, hook ) {
5248		Object.defineProperty( jQuery.Event.prototype, name, {
5249			enumerable: true,
5250			configurable: true,
5251
5252			get: isFunction( hook ) ?
5253				function() {
5254					if ( this.originalEvent ) {
5255						return hook( this.originalEvent );
5256					}
5257				} :
5258				function() {
5259					if ( this.originalEvent ) {
5260						return this.originalEvent[ name ];
5261					}
5262				},
5263
5264			set: function( value ) {
5265				Object.defineProperty( this, name, {
5266					enumerable: true,
5267					configurable: true,
5268					writable: true,
5269					value: value
5270				} );
5271			}
5272		} );
5273	},
5274
5275	fix: function( originalEvent ) {
5276		return originalEvent[ jQuery.expando ] ?
5277			originalEvent :
5278			new jQuery.Event( originalEvent );
5279	},
5280
5281	special: {
5282		load: {
5283
5284			// Prevent triggered image.load events from bubbling to window.load
5285			noBubble: true
5286		},
5287		click: {
5288
5289			// Utilize native event to ensure correct state for checkable inputs
5290			setup: function( data ) {
5291
5292				// For mutual compressibility with _default, replace `this` access with a local var.
5293				// `|| data` is dead code meant only to preserve the variable through minification.
5294				var el = this || data;
5295
5296				// Claim the first handler
5297				if ( rcheckableType.test( el.type ) &&
5298					el.click && nodeName( el, "input" ) ) {
5299
5300					// dataPriv.set( el, "click", ... )
5301					leverageNative( el, "click", true );
5302				}
5303
5304				// Return false to allow normal processing in the caller
5305				return false;
5306			},
5307			trigger: function( data ) {
5308
5309				// For mutual compressibility with _default, replace `this` access with a local var.
5310				// `|| data` is dead code meant only to preserve the variable through minification.
5311				var el = this || data;
5312
5313				// Force setup before triggering a click
5314				if ( rcheckableType.test( el.type ) &&
5315					el.click && nodeName( el, "input" ) ) {
5316
5317					leverageNative( el, "click" );
5318				}
5319
5320				// Return non-false to allow normal event-path propagation
5321				return true;
5322			},
5323
5324			// For cross-browser consistency, suppress native .click() on links
5325			// Also prevent it if we're currently inside a leveraged native-event stack
5326			_default: function( event ) {
5327				var target = event.target;
5328				return rcheckableType.test( target.type ) &&
5329					target.click && nodeName( target, "input" ) &&
5330					dataPriv.get( target, "click" ) ||
5331					nodeName( target, "a" );
5332			}
5333		},
5334
5335		beforeunload: {
5336			postDispatch: function( event ) {
5337
5338				// Support: Firefox 20+
5339				// Firefox doesn't alert if the returnValue field is not set.
5340				if ( event.result !== undefined && event.originalEvent ) {
5341					event.originalEvent.returnValue = event.result;
5342				}
5343			}
5344		}
5345	}
5346};
5347
5348// Ensure the presence of an event listener that handles manually-triggered
5349// synthetic events by interrupting progress until reinvoked in response to
5350// *native* events that it fires directly, ensuring that state changes have
5351// already occurred before other listeners are invoked.
5352function leverageNative( el, type, isSetup ) {
5353
5354	// Missing `isSetup` indicates a trigger call, which must force setup through jQuery.event.add
5355	if ( !isSetup ) {
5356		if ( dataPriv.get( el, type ) === undefined ) {
5357			jQuery.event.add( el, type, returnTrue );
5358		}
5359		return;
5360	}
5361
5362	// Register the controller as a special universal handler for all event namespaces
5363	dataPriv.set( el, type, false );
5364	jQuery.event.add( el, type, {
5365		namespace: false,
5366		handler: function( event ) {
5367			var result,
5368				saved = dataPriv.get( this, type );
5369
5370			if ( ( event.isTrigger & 1 ) && this[ type ] ) {
5371
5372				// Interrupt processing of the outer synthetic .trigger()ed event
5373				if ( !saved ) {
5374
5375					// Store arguments for use when handling the inner native event
5376					// There will always be at least one argument (an event object), so this array
5377					// will not be confused with a leftover capture object.
5378					saved = slice.call( arguments );
5379					dataPriv.set( this, type, saved );
5380
5381					// Trigger the native event and capture its result
5382					this[ type ]();
5383					result = dataPriv.get( this, type );
5384					dataPriv.set( this, type, false );
5385
5386					if ( saved !== result ) {
5387
5388						// Cancel the outer synthetic event
5389						event.stopImmediatePropagation();
5390						event.preventDefault();
5391
5392						return result;
5393					}
5394
5395				// If this is an inner synthetic event for an event with a bubbling surrogate
5396				// (focus or blur), assume that the surrogate already propagated from triggering
5397				// the native event and prevent that from happening again here.
5398				// This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the
5399				// bubbling surrogate propagates *after* the non-bubbling base), but that seems
5400				// less bad than duplication.
5401				} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {
5402					event.stopPropagation();
5403				}
5404
5405			// If this is a native event triggered above, everything is now in order
5406			// Fire an inner synthetic event with the original arguments
5407			} else if ( saved ) {
5408
5409				// ...and capture the result
5410				dataPriv.set( this, type, jQuery.event.trigger(
5411					saved[ 0 ],
5412					saved.slice( 1 ),
5413					this
5414				) );
5415
5416				// Abort handling of the native event by all jQuery handlers while allowing
5417				// native handlers on the same element to run. On target, this is achieved
5418				// by stopping immediate propagation just on the jQuery event. However,
5419				// the native event is re-wrapped by a jQuery one on each level of the
5420				// propagation so the only way to stop it for jQuery is to stop it for
5421				// everyone via native `stopPropagation()`. This is not a problem for
5422				// focus/blur which don't bubble, but it does also stop click on checkboxes
5423				// and radios. We accept this limitation.
5424				event.stopPropagation();
5425				event.isImmediatePropagationStopped = returnTrue;
5426			}
5427		}
5428	} );
5429}
5430
5431jQuery.removeEvent = function( elem, type, handle ) {
5432
5433	// This "if" is needed for plain objects
5434	if ( elem.removeEventListener ) {
5435		elem.removeEventListener( type, handle );
5436	}
5437};
5438
5439jQuery.Event = function( src, props ) {
5440
5441	// Allow instantiation without the 'new' keyword
5442	if ( !( this instanceof jQuery.Event ) ) {
5443		return new jQuery.Event( src, props );
5444	}
5445
5446	// Event object
5447	if ( src && src.type ) {
5448		this.originalEvent = src;
5449		this.type = src.type;
5450
5451		// Events bubbling up the document may have been marked as prevented
5452		// by a handler lower down the tree; reflect the correct value.
5453		this.isDefaultPrevented = src.defaultPrevented ||
5454				src.defaultPrevented === undefined &&
5455
5456				// Support: Android <=2.3 only
5457				src.returnValue === false ?
5458			returnTrue :
5459			returnFalse;
5460
5461		// Create target properties
5462		// Support: Safari <=6 - 7 only
5463		// Target should not be a text node (trac-504, trac-13143)
5464		this.target = ( src.target && src.target.nodeType === 3 ) ?
5465			src.target.parentNode :
5466			src.target;
5467
5468		this.currentTarget = src.currentTarget;
5469		this.relatedTarget = src.relatedTarget;
5470
5471	// Event type
5472	} else {
5473		this.type = src;
5474	}
5475
5476	// Put explicitly provided properties onto the event object
5477	if ( props ) {
5478		jQuery.extend( this, props );
5479	}
5480
5481	// Create a timestamp if incoming event doesn't have one
5482	this.timeStamp = src && src.timeStamp || Date.now();
5483
5484	// Mark it as fixed
5485	this[ jQuery.expando ] = true;
5486};
5487
5488// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
5489// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
5490jQuery.Event.prototype = {
5491	constructor: jQuery.Event,
5492	isDefaultPrevented: returnFalse,
5493	isPropagationStopped: returnFalse,
5494	isImmediatePropagationStopped: returnFalse,
5495	isSimulated: false,
5496
5497	preventDefault: function() {
5498		var e = this.originalEvent;
5499
5500		this.isDefaultPrevented = returnTrue;
5501
5502		if ( e && !this.isSimulated ) {
5503			e.preventDefault();
5504		}
5505	},
5506	stopPropagation: function() {
5507		var e = this.originalEvent;
5508
5509		this.isPropagationStopped = returnTrue;
5510
5511		if ( e && !this.isSimulated ) {
5512			e.stopPropagation();
5513		}
5514	},
5515	stopImmediatePropagation: function() {
5516		var e = this.originalEvent;
5517
5518		this.isImmediatePropagationStopped = returnTrue;
5519
5520		if ( e && !this.isSimulated ) {
5521			e.stopImmediatePropagation();
5522		}
5523
5524		this.stopPropagation();
5525	}
5526};
5527
5528// Includes all common event props including KeyEvent and MouseEvent specific props
5529jQuery.each( {
5530	altKey: true,
5531	bubbles: true,
5532	cancelable: true,
5533	changedTouches: true,
5534	ctrlKey: true,
5535	detail: true,
5536	eventPhase: true,
5537	metaKey: true,
5538	pageX: true,
5539	pageY: true,
5540	shiftKey: true,
5541	view: true,
5542	"char": true,
5543	code: true,
5544	charCode: true,
5545	key: true,
5546	keyCode: true,
5547	button: true,
5548	buttons: true,
5549	clientX: true,
5550	clientY: true,
5551	offsetX: true,
5552	offsetY: true,
5553	pointerId: true,
5554	pointerType: true,
5555	screenX: true,
5556	screenY: true,
5557	targetTouches: true,
5558	toElement: true,
5559	touches: true,
5560	which: true
5561}, jQuery.event.addProp );
5562
5563jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) {
5564
5565	function focusMappedHandler( nativeEvent ) {
5566		if ( document.documentMode ) {
5567
5568			// Support: IE 11+
5569			// Attach a single focusin/focusout handler on the document while someone wants
5570			// focus/blur. This is because the former are synchronous in IE while the latter
5571			// are async. In other browsers, all those handlers are invoked synchronously.
5572
5573			// `handle` from private data would already wrap the event, but we need
5574			// to change the `type` here.
5575			var handle = dataPriv.get( this, "handle" ),
5576				event = jQuery.event.fix( nativeEvent );
5577			event.type = nativeEvent.type === "focusin" ? "focus" : "blur";
5578			event.isSimulated = true;
5579
5580			// First, handle focusin/focusout
5581			handle( nativeEvent );
5582
5583			// ...then, handle focus/blur
5584			//
5585			// focus/blur don't bubble while focusin/focusout do; simulate the former by only
5586			// invoking the handler at the lower level.
5587			if ( event.target === event.currentTarget ) {
5588
5589				// The setup part calls `leverageNative`, which, in turn, calls
5590				// `jQuery.event.add`, so event handle will already have been set
5591				// by this point.
5592				handle( event );
5593			}
5594		} else {
5595
5596			// For non-IE browsers, attach a single capturing handler on the document
5597			// while someone wants focusin/focusout.
5598			jQuery.event.simulate( delegateType, nativeEvent.target,
5599				jQuery.event.fix( nativeEvent ) );
5600		}
5601	}
5602
5603	jQuery.event.special[ type ] = {
5604
5605		// Utilize native event if possible so blur/focus sequence is correct
5606		setup: function() {
5607
5608			var attaches;
5609
5610			// Claim the first handler
5611			// dataPriv.set( this, "focus", ... )
5612			// dataPriv.set( this, "blur", ... )
5613			leverageNative( this, type, true );
5614
5615			if ( document.documentMode ) {
5616
5617				// Support: IE 9 - 11+
5618				// We use the same native handler for focusin & focus (and focusout & blur)
5619				// so we need to coordinate setup & teardown parts between those events.
5620				// Use `delegateType` as the key as `type` is already used by `leverageNative`.
5621				attaches = dataPriv.get( this, delegateType );
5622				if ( !attaches ) {
5623					this.addEventListener( delegateType, focusMappedHandler );
5624				}
5625				dataPriv.set( this, delegateType, ( attaches || 0 ) + 1 );
5626			} else {
5627
5628				// Return false to allow normal processing in the caller
5629				return false;
5630			}
5631		},
5632		trigger: function() {
5633
5634			// Force setup before trigger
5635			leverageNative( this, type );
5636
5637			// Return non-false to allow normal event-path propagation
5638			return true;
5639		},
5640
5641		teardown: function() {
5642			var attaches;
5643
5644			if ( document.documentMode ) {
5645				attaches = dataPriv.get( this, delegateType ) - 1;
5646				if ( !attaches ) {
5647					this.removeEventListener( delegateType, focusMappedHandler );
5648					dataPriv.remove( this, delegateType );
5649				} else {
5650					dataPriv.set( this, delegateType, attaches );
5651				}
5652			} else {
5653
5654				// Return false to indicate standard teardown should be applied
5655				return false;
5656			}
5657		},
5658
5659		// Suppress native focus or blur if we're currently inside
5660		// a leveraged native-event stack
5661		_default: function( event ) {
5662			return dataPriv.get( event.target, type );
5663		},
5664
5665		delegateType: delegateType
5666	};
5667
5668	// Support: Firefox <=44
5669	// Firefox doesn't have focus(in | out) events
5670	// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
5671	//
5672	// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
5673	// focus(in | out) events fire after focus & blur events,
5674	// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
5675	// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
5676	//
5677	// Support: IE 9 - 11+
5678	// To preserve relative focusin/focus & focusout/blur event order guaranteed on the 3.x branch,
5679	// attach a single handler for both events in IE.
5680	jQuery.event.special[ delegateType ] = {
5681		setup: function() {
5682
5683			// Handle: regular nodes (via `this.ownerDocument`), window
5684			// (via `this.document`) & document (via `this`).
5685			var doc = this.ownerDocument || this.document || this,
5686				dataHolder = document.documentMode ? this : doc,
5687				attaches = dataPriv.get( dataHolder, delegateType );
5688
5689			// Support: IE 9 - 11+
5690			// We use the same native handler for focusin & focus (and focusout & blur)
5691			// so we need to coordinate setup & teardown parts between those events.
5692			// Use `delegateType` as the key as `type` is already used by `leverageNative`.
5693			if ( !attaches ) {
5694				if ( document.documentMode ) {
5695					this.addEventListener( delegateType, focusMappedHandler );
5696				} else {
5697					doc.addEventListener( type, focusMappedHandler, true );
5698				}
5699			}
5700			dataPriv.set( dataHolder, delegateType, ( attaches || 0 ) + 1 );
5701		},
5702		teardown: function() {
5703			var doc = this.ownerDocument || this.document || this,
5704				dataHolder = document.documentMode ? this : doc,
5705				attaches = dataPriv.get( dataHolder, delegateType ) - 1;
5706
5707			if ( !attaches ) {
5708				if ( document.documentMode ) {
5709					this.removeEventListener( delegateType, focusMappedHandler );
5710				} else {
5711					doc.removeEventListener( type, focusMappedHandler, true );
5712				}
5713				dataPriv.remove( dataHolder, delegateType );
5714			} else {
5715				dataPriv.set( dataHolder, delegateType, attaches );
5716			}
5717		}
5718	};
5719} );
5720
5721// Create mouseenter/leave events using mouseover/out and event-time checks
5722// so that event delegation works in jQuery.
5723// Do the same for pointerenter/pointerleave and pointerover/pointerout
5724//
5725// Support: Safari 7 only
5726// Safari sends mouseenter too often; see:
5727// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
5728// for the description of the bug (it existed in older Chrome versions as well).
5729jQuery.each( {
5730	mouseenter: "mouseover",
5731	mouseleave: "mouseout",
5732	pointerenter: "pointerover",
5733	pointerleave: "pointerout"
5734}, function( orig, fix ) {
5735	jQuery.event.special[ orig ] = {
5736		delegateType: fix,
5737		bindType: fix,
5738
5739		handle: function( event ) {
5740			var ret,
5741				target = this,
5742				related = event.relatedTarget,
5743				handleObj = event.handleObj;
5744
5745			// For mouseenter/leave call the handler if related is outside the target.
5746			// NB: No relatedTarget if the mouse left/entered the browser window
5747			if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
5748				event.type = handleObj.origType;
5749				ret = handleObj.handler.apply( this, arguments );
5750				event.type = fix;
5751			}
5752			return ret;
5753		}
5754	};
5755} );
5756
5757jQuery.fn.extend( {
5758
5759	on: function( types, selector, data, fn ) {
5760		return on( this, types, selector, data, fn );
5761	},
5762	one: function( types, selector, data, fn ) {
5763		return on( this, types, selector, data, fn, 1 );
5764	},
5765	off: function( types, selector, fn ) {
5766		var handleObj, type;
5767		if ( types && types.preventDefault && types.handleObj ) {
5768
5769			// ( event )  dispatched jQuery.Event
5770			handleObj = types.handleObj;
5771			jQuery( types.delegateTarget ).off(
5772				handleObj.namespace ?
5773					handleObj.origType + "." + handleObj.namespace :
5774					handleObj.origType,
5775				handleObj.selector,
5776				handleObj.handler
5777			);
5778			return this;
5779		}
5780		if ( typeof types === "object" ) {
5781
5782			// ( types-object [, selector] )
5783			for ( type in types ) {
5784				this.off( type, selector, types[ type ] );
5785			}
5786			return this;
5787		}
5788		if ( selector === false || typeof selector === "function" ) {
5789
5790			// ( types [, fn] )
5791			fn = selector;
5792			selector = undefined;
5793		}
5794		if ( fn === false ) {
5795			fn = returnFalse;
5796		}
5797		return this.each( function() {
5798			jQuery.event.remove( this, types, fn, selector );
5799		} );
5800	}
5801} );
5802
5803
5804var
5805
5806	// Support: IE <=10 - 11, Edge 12 - 13 only
5807	// In IE/Edge using regex groups here causes severe slowdowns.
5808	// See https://connect.microsoft.com/IE/feedback/details/1736512/
5809	rnoInnerhtml = /<script|<style|<link/i,
5810
5811	// checked="checked" or checked
5812	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5813
5814	rcleanScript = /^\s*<!\[CDATA\[|\]\]>\s*$/g;
5815
5816// Prefer a tbody over its parent table for containing new rows
5817function manipulationTarget( elem, content ) {
5818	if ( nodeName( elem, "table" ) &&
5819		nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
5820
5821		return jQuery( elem ).children( "tbody" )[ 0 ] || elem;
5822	}
5823
5824	return elem;
5825}
5826
5827// Replace/restore the type attribute of script elements for safe DOM manipulation
5828function disableScript( elem ) {
5829	elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
5830	return elem;
5831}
5832function restoreScript( elem ) {
5833	if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) {
5834		elem.type = elem.type.slice( 5 );
5835	} else {
5836		elem.removeAttribute( "type" );
5837	}
5838
5839	return elem;
5840}
5841
5842function cloneCopyEvent( src, dest ) {
5843	var i, l, type, pdataOld, udataOld, udataCur, events;
5844
5845	if ( dest.nodeType !== 1 ) {
5846		return;
5847	}
5848
5849	// 1. Copy private data: events, handlers, etc.
5850	if ( dataPriv.hasData( src ) ) {
5851		pdataOld = dataPriv.get( src );
5852		events = pdataOld.events;
5853
5854		if ( events ) {
5855			dataPriv.remove( dest, "handle events" );
5856
5857			for ( type in events ) {
5858				for ( i = 0, l = events[ type ].length; i < l; i++ ) {
5859					jQuery.event.add( dest, type, events[ type ][ i ] );
5860				}
5861			}
5862		}
5863	}
5864
5865	// 2. Copy user data
5866	if ( dataUser.hasData( src ) ) {
5867		udataOld = dataUser.access( src );
5868		udataCur = jQuery.extend( {}, udataOld );
5869
5870		dataUser.set( dest, udataCur );
5871	}
5872}
5873
5874// Fix IE bugs, see support tests
5875function fixInput( src, dest ) {
5876	var nodeName = dest.nodeName.toLowerCase();
5877
5878	// Fails to persist the checked state of a cloned checkbox or radio button.
5879	if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
5880		dest.checked = src.checked;
5881
5882	// Fails to return the selected option to the default selected state when cloning options
5883	} else if ( nodeName === "input" || nodeName === "textarea" ) {
5884		dest.defaultValue = src.defaultValue;
5885	}
5886}
5887
5888function domManip( collection, args, callback, ignored ) {
5889
5890	// Flatten any nested arrays
5891	args = flat( args );
5892
5893	var fragment, first, scripts, hasScripts, node, doc,
5894		i = 0,
5895		l = collection.length,
5896		iNoClone = l - 1,
5897		value = args[ 0 ],
5898		valueIsFunction = isFunction( value );
5899
5900	// We can't cloneNode fragments that contain checked, in WebKit
5901	if ( valueIsFunction ||
5902			( l > 1 && typeof value === "string" &&
5903				!support.checkClone && rchecked.test( value ) ) ) {
5904		return collection.each( function( index ) {
5905			var self = collection.eq( index );
5906			if ( valueIsFunction ) {
5907				args[ 0 ] = value.call( this, index, self.html() );
5908			}
5909			domManip( self, args, callback, ignored );
5910		} );
5911	}
5912
5913	if ( l ) {
5914		fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
5915		first = fragment.firstChild;
5916
5917		if ( fragment.childNodes.length === 1 ) {
5918			fragment = first;
5919		}
5920
5921		// Require either new content or an interest in ignored elements to invoke the callback
5922		if ( first || ignored ) {
5923			scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
5924			hasScripts = scripts.length;
5925
5926			// Use the original fragment for the last item
5927			// instead of the first because it can end up
5928			// being emptied incorrectly in certain situations (trac-8070).
5929			for ( ; i < l; i++ ) {
5930				node = fragment;
5931
5932				if ( i !== iNoClone ) {
5933					node = jQuery.clone( node, true, true );
5934
5935					// Keep references to cloned scripts for later restoration
5936					if ( hasScripts ) {
5937
5938						// Support: Android <=4.0 only, PhantomJS 1 only
5939						// push.apply(_, arraylike) throws on ancient WebKit
5940						jQuery.merge( scripts, getAll( node, "script" ) );
5941					}
5942				}
5943
5944				callback.call( collection[ i ], node, i );
5945			}
5946
5947			if ( hasScripts ) {
5948				doc = scripts[ scripts.length - 1 ].ownerDocument;
5949
5950				// Reenable scripts
5951				jQuery.map( scripts, restoreScript );
5952
5953				// Evaluate executable scripts on first document insertion
5954				for ( i = 0; i < hasScripts; i++ ) {
5955					node = scripts[ i ];
5956					if ( rscriptType.test( node.type || "" ) &&
5957						!dataPriv.access( node, "globalEval" ) &&
5958						jQuery.contains( doc, node ) ) {
5959
5960						if ( node.src && ( node.type || "" ).toLowerCase()  !== "module" ) {
5961
5962							// Optional AJAX dependency, but won't run scripts if not present
5963							if ( jQuery._evalUrl && !node.noModule ) {
5964								jQuery._evalUrl( node.src, {
5965									nonce: node.nonce || node.getAttribute( "nonce" )
5966								}, doc );
5967							}
5968						} else {
5969
5970							// Unwrap a CDATA section containing script contents. This shouldn't be
5971							// needed as in XML documents they're already not visible when
5972							// inspecting element contents and in HTML documents they have no
5973							// meaning but we're preserving that logic for backwards compatibility.
5974							// This will be removed completely in 4.0. See gh-4904.
5975							DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc );
5976						}
5977					}
5978				}
5979			}
5980		}
5981	}
5982
5983	return collection;
5984}
5985
5986function remove( elem, selector, keepData ) {
5987	var node,
5988		nodes = selector ? jQuery.filter( selector, elem ) : elem,
5989		i = 0;
5990
5991	for ( ; ( node = nodes[ i ] ) != null; i++ ) {
5992		if ( !keepData && node.nodeType === 1 ) {
5993			jQuery.cleanData( getAll( node ) );
5994		}
5995
5996		if ( node.parentNode ) {
5997			if ( keepData && isAttached( node ) ) {
5998				setGlobalEval( getAll( node, "script" ) );
5999			}
6000			node.parentNode.removeChild( node );
6001		}
6002	}
6003
6004	return elem;
6005}
6006
6007jQuery.extend( {
6008	htmlPrefilter: function( html ) {
6009		return html;
6010	},
6011
6012	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
6013		var i, l, srcElements, destElements,
6014			clone = elem.cloneNode( true ),
6015			inPage = isAttached( elem );
6016
6017		// Fix IE cloning issues
6018		if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
6019				!jQuery.isXMLDoc( elem ) ) {
6020
6021			// We eschew jQuery#find here for performance reasons:
6022			// https://jsperf.com/getall-vs-sizzle/2
6023			destElements = getAll( clone );
6024			srcElements = getAll( elem );
6025
6026			for ( i = 0, l = srcElements.length; i < l; i++ ) {
6027				fixInput( srcElements[ i ], destElements[ i ] );
6028			}
6029		}
6030
6031		// Copy the events from the original to the clone
6032		if ( dataAndEvents ) {
6033			if ( deepDataAndEvents ) {
6034				srcElements = srcElements || getAll( elem );
6035				destElements = destElements || getAll( clone );
6036
6037				for ( i = 0, l = srcElements.length; i < l; i++ ) {
6038					cloneCopyEvent( srcElements[ i ], destElements[ i ] );
6039				}
6040			} else {
6041				cloneCopyEvent( elem, clone );
6042			}
6043		}
6044
6045		// Preserve script evaluation history
6046		destElements = getAll( clone, "script" );
6047		if ( destElements.length > 0 ) {
6048			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
6049		}
6050
6051		// Return the cloned set
6052		return clone;
6053	},
6054
6055	cleanData: function( elems ) {
6056		var data, elem, type,
6057			special = jQuery.event.special,
6058			i = 0;
6059
6060		for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
6061			if ( acceptData( elem ) ) {
6062				if ( ( data = elem[ dataPriv.expando ] ) ) {
6063					if ( data.events ) {
6064						for ( type in data.events ) {
6065							if ( special[ type ] ) {
6066								jQuery.event.remove( elem, type );
6067
6068							// This is a shortcut to avoid jQuery.event.remove's overhead
6069							} else {
6070								jQuery.removeEvent( elem, type, data.handle );
6071							}
6072						}
6073					}
6074
6075					// Support: Chrome <=35 - 45+
6076					// Assign undefined instead of using delete, see Data#remove
6077					elem[ dataPriv.expando ] = undefined;
6078				}
6079				if ( elem[ dataUser.expando ] ) {
6080
6081					// Support: Chrome <=35 - 45+
6082					// Assign undefined instead of using delete, see Data#remove
6083					elem[ dataUser.expando ] = undefined;
6084				}
6085			}
6086		}
6087	}
6088} );
6089
6090jQuery.fn.extend( {
6091	detach: function( selector ) {
6092		return remove( this, selector, true );
6093	},
6094
6095	remove: function( selector ) {
6096		return remove( this, selector );
6097	},
6098
6099	text: function( value ) {
6100		return access( this, function( value ) {
6101			return value === undefined ?
6102				jQuery.text( this ) :
6103				this.empty().each( function() {
6104					if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
6105						this.textContent = value;
6106					}
6107				} );
6108		}, null, value, arguments.length );
6109	},
6110
6111	append: function() {
6112		return domManip( this, arguments, function( elem ) {
6113			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
6114				var target = manipulationTarget( this, elem );
6115				target.appendChild( elem );
6116			}
6117		} );
6118	},
6119
6120	prepend: function() {
6121		return domManip( this, arguments, function( elem ) {
6122			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
6123				var target = manipulationTarget( this, elem );
6124				target.insertBefore( elem, target.firstChild );
6125			}
6126		} );
6127	},
6128
6129	before: function() {
6130		return domManip( this, arguments, function( elem ) {
6131			if ( this.parentNode ) {
6132				this.parentNode.insertBefore( elem, this );
6133			}
6134		} );
6135	},
6136
6137	after: function() {
6138		return domManip( this, arguments, function( elem ) {
6139			if ( this.parentNode ) {
6140				this.parentNode.insertBefore( elem, this.nextSibling );
6141			}
6142		} );
6143	},
6144
6145	empty: function() {
6146		var elem,
6147			i = 0;
6148
6149		for ( ; ( elem = this[ i ] ) != null; i++ ) {
6150			if ( elem.nodeType === 1 ) {
6151
6152				// Prevent memory leaks
6153				jQuery.cleanData( getAll( elem, false ) );
6154
6155				// Remove any remaining nodes
6156				elem.textContent = "";
6157			}
6158		}
6159
6160		return this;
6161	},
6162
6163	clone: function( dataAndEvents, deepDataAndEvents ) {
6164		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
6165		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
6166
6167		return this.map( function() {
6168			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
6169		} );
6170	},
6171
6172	html: function( value ) {
6173		return access( this, function( value ) {
6174			var elem = this[ 0 ] || {},
6175				i = 0,
6176				l = this.length;
6177
6178			if ( value === undefined && elem.nodeType === 1 ) {
6179				return elem.innerHTML;
6180			}
6181
6182			// See if we can take a shortcut and just use innerHTML
6183			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
6184				!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
6185
6186				value = jQuery.htmlPrefilter( value );
6187
6188				try {
6189					for ( ; i < l; i++ ) {
6190						elem = this[ i ] || {};
6191
6192						// Remove element nodes and prevent memory leaks
6193						if ( elem.nodeType === 1 ) {
6194							jQuery.cleanData( getAll( elem, false ) );
6195							elem.innerHTML = value;
6196						}
6197					}
6198
6199					elem = 0;
6200
6201				// If using innerHTML throws an exception, use the fallback method
6202				} catch ( e ) {}
6203			}
6204
6205			if ( elem ) {
6206				this.empty().append( value );
6207			}
6208		}, null, value, arguments.length );
6209	},
6210
6211	replaceWith: function() {
6212		var ignored = [];
6213
6214		// Make the changes, replacing each non-ignored context element with the new content
6215		return domManip( this, arguments, function( elem ) {
6216			var parent = this.parentNode;
6217
6218			if ( jQuery.inArray( this, ignored ) < 0 ) {
6219				jQuery.cleanData( getAll( this ) );
6220				if ( parent ) {
6221					parent.replaceChild( elem, this );
6222				}
6223			}
6224
6225		// Force callback invocation
6226		}, ignored );
6227	}
6228} );
6229
6230jQuery.each( {
6231	appendTo: "append",
6232	prependTo: "prepend",
6233	insertBefore: "before",
6234	insertAfter: "after",
6235	replaceAll: "replaceWith"
6236}, function( name, original ) {
6237	jQuery.fn[ name ] = function( selector ) {
6238		var elems,
6239			ret = [],
6240			insert = jQuery( selector ),
6241			last = insert.length - 1,
6242			i = 0;
6243
6244		for ( ; i <= last; i++ ) {
6245			elems = i === last ? this : this.clone( true );
6246			jQuery( insert[ i ] )[ original ]( elems );
6247
6248			// Support: Android <=4.0 only, PhantomJS 1 only
6249			// .get() because push.apply(_, arraylike) throws on ancient WebKit
6250			push.apply( ret, elems.get() );
6251		}
6252
6253		return this.pushStack( ret );
6254	};
6255} );
6256var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
6257
6258var rcustomProp = /^--/;
6259
6260
6261var getStyles = function( elem ) {
6262
6263		// Support: IE <=11 only, Firefox <=30 (trac-15098, trac-14150)
6264		// IE throws on elements created in popups
6265		// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
6266		var view = elem.ownerDocument.defaultView;
6267
6268		if ( !view || !view.opener ) {
6269			view = window;
6270		}
6271
6272		return view.getComputedStyle( elem );
6273	};
6274
6275var swap = function( elem, options, callback ) {
6276	var ret, name,
6277		old = {};
6278
6279	// Remember the old values, and insert the new ones
6280	for ( name in options ) {
6281		old[ name ] = elem.style[ name ];
6282		elem.style[ name ] = options[ name ];
6283	}
6284
6285	ret = callback.call( elem );
6286
6287	// Revert the old values
6288	for ( name in options ) {
6289		elem.style[ name ] = old[ name ];
6290	}
6291
6292	return ret;
6293};
6294
6295
6296var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );
6297
6298
6299
6300( function() {
6301
6302	// Executing both pixelPosition & boxSizingReliable tests require only one layout
6303	// so they're executed at the same time to save the second computation.
6304	function computeStyleTests() {
6305
6306		// This is a singleton, we need to execute it only once
6307		if ( !div ) {
6308			return;
6309		}
6310
6311		container.style.cssText = "position:absolute;left:-11111px;width:60px;" +
6312			"margin-top:1px;padding:0;border:0";
6313		div.style.cssText =
6314			"position:relative;display:block;box-sizing:border-box;overflow:scroll;" +
6315			"margin:auto;border:1px;padding:1px;" +
6316			"width:60%;top:1%";
6317		documentElement.appendChild( container ).appendChild( div );
6318
6319		var divStyle = window.getComputedStyle( div );
6320		pixelPositionVal = divStyle.top !== "1%";
6321
6322		// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
6323		reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;
6324
6325		// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
6326		// Some styles come back with percentage values, even though they shouldn't
6327		div.style.right = "60%";
6328		pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;
6329
6330		// Support: IE 9 - 11 only
6331		// Detect misreporting of content dimensions for box-sizing:border-box elements
6332		boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;
6333
6334		// Support: IE 9 only
6335		// Detect overflow:scroll screwiness (gh-3699)
6336		// Support: Chrome <=64
6337		// Don't get tricked when zoom affects offsetWidth (gh-4029)
6338		div.style.position = "absolute";
6339		scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;
6340
6341		documentElement.removeChild( container );
6342
6343		// Nullify the div so it wouldn't be stored in the memory and
6344		// it will also be a sign that checks already performed
6345		div = null;
6346	}
6347
6348	function roundPixelMeasures( measure ) {
6349		return Math.round( parseFloat( measure ) );
6350	}
6351
6352	var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,
6353		reliableTrDimensionsVal, reliableMarginLeftVal,
6354		container = document.createElement( "div" ),
6355		div = document.createElement( "div" );
6356
6357	// Finish early in limited (non-browser) environments
6358	if ( !div.style ) {
6359		return;
6360	}
6361
6362	// Support: IE <=9 - 11 only
6363	// Style of cloned element affects source element cloned (trac-8908)
6364	div.style.backgroundClip = "content-box";
6365	div.cloneNode( true ).style.backgroundClip = "";
6366	support.clearCloneStyle = div.style.backgroundClip === "content-box";
6367
6368	jQuery.extend( support, {
6369		boxSizingReliable: function() {
6370			computeStyleTests();
6371			return boxSizingReliableVal;
6372		},
6373		pixelBoxStyles: function() {
6374			computeStyleTests();
6375			return pixelBoxStylesVal;
6376		},
6377		pixelPosition: function() {
6378			computeStyleTests();
6379			return pixelPositionVal;
6380		},
6381		reliableMarginLeft: function() {
6382			computeStyleTests();
6383			return reliableMarginLeftVal;
6384		},
6385		scrollboxSize: function() {
6386			computeStyleTests();
6387			return scrollboxSizeVal;
6388		},
6389
6390		// Support: IE 9 - 11+, Edge 15 - 18+
6391		// IE/Edge misreport `getComputedStyle` of table rows with width/height
6392		// set in CSS while `offset*` properties report correct values.
6393		// Behavior in IE 9 is more subtle than in newer versions & it passes
6394		// some versions of this test; make sure not to make it pass there!
6395		//
6396		// Support: Firefox 70+
6397		// Only Firefox includes border widths
6398		// in computed dimensions. (gh-4529)
6399		reliableTrDimensions: function() {
6400			var table, tr, trChild, trStyle;
6401			if ( reliableTrDimensionsVal == null ) {
6402				table = document.createElement( "table" );
6403				tr = document.createElement( "tr" );
6404				trChild = document.createElement( "div" );
6405
6406				table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate";
6407				tr.style.cssText = "border:1px solid";
6408
6409				// Support: Chrome 86+
6410				// Height set through cssText does not get applied.
6411				// Computed height then comes back as 0.
6412				tr.style.height = "1px";
6413				trChild.style.height = "9px";
6414
6415				// Support: Android 8 Chrome 86+
6416				// In our bodyBackground.html iframe,
6417				// display for all div elements is set to "inline",
6418				// which causes a problem only in Android 8 Chrome 86.
6419				// Ensuring the div is display: block
6420				// gets around this issue.
6421				trChild.style.display = "block";
6422
6423				documentElement
6424					.appendChild( table )
6425					.appendChild( tr )
6426					.appendChild( trChild );
6427
6428				trStyle = window.getComputedStyle( tr );
6429				reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +
6430					parseInt( trStyle.borderTopWidth, 10 ) +
6431					parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;
6432
6433				documentElement.removeChild( table );
6434			}
6435			return reliableTrDimensionsVal;
6436		}
6437	} );
6438} )();
6439
6440
6441function curCSS( elem, name, computed ) {
6442	var width, minWidth, maxWidth, ret,
6443		isCustomProp = rcustomProp.test( name ),
6444
6445		// Support: Firefox 51+
6446		// Retrieving style before computed somehow
6447		// fixes an issue with getting wrong values
6448		// on detached elements
6449		style = elem.style;
6450
6451	computed = computed || getStyles( elem );
6452
6453	// getPropertyValue is needed for:
6454	//   .css('filter') (IE 9 only, trac-12537)
6455	//   .css('--customProperty) (gh-3144)
6456	if ( computed ) {
6457
6458		// Support: IE <=9 - 11+
6459		// IE only supports `"float"` in `getPropertyValue`; in computed styles
6460		// it's only available as `"cssFloat"`. We no longer modify properties
6461		// sent to `.css()` apart from camelCasing, so we need to check both.
6462		// Normally, this would create difference in behavior: if
6463		// `getPropertyValue` returns an empty string, the value returned
6464		// by `.css()` would be `undefined`. This is usually the case for
6465		// disconnected elements. However, in IE even disconnected elements
6466		// with no styles return `"none"` for `getPropertyValue( "float" )`
6467		ret = computed.getPropertyValue( name ) || computed[ name ];
6468
6469		if ( isCustomProp && ret ) {
6470
6471			// Support: Firefox 105+, Chrome <=105+
6472			// Spec requires trimming whitespace for custom properties (gh-4926).
6473			// Firefox only trims leading whitespace. Chrome just collapses
6474			// both leading & trailing whitespace to a single space.
6475			//
6476			// Fall back to `undefined` if empty string returned.
6477			// This collapses a missing definition with property defined
6478			// and set to an empty string but there's no standard API
6479			// allowing us to differentiate them without a performance penalty
6480			// and returning `undefined` aligns with older jQuery.
6481			//
6482			// rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED
6483			// as whitespace while CSS does not, but this is not a problem
6484			// because CSS preprocessing replaces them with U+000A LINE FEED
6485			// (which *is* CSS whitespace)
6486			// https://www.w3.org/TR/css-syntax-3/#input-preprocessing
6487			ret = ret.replace( rtrimCSS, "$1" ) || undefined;
6488		}
6489
6490		if ( ret === "" && !isAttached( elem ) ) {
6491			ret = jQuery.style( elem, name );
6492		}
6493
6494		// A tribute to the "awesome hack by Dean Edwards"
6495		// Android Browser returns percentage for some values,
6496		// but width seems to be reliably pixels.
6497		// This is against the CSSOM draft spec:
6498		// https://drafts.csswg.org/cssom/#resolved-values
6499		if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {
6500
6501			// Remember the original values
6502			width = style.width;
6503			minWidth = style.minWidth;
6504			maxWidth = style.maxWidth;
6505
6506			// Put in the new values to get a computed value out
6507			style.minWidth = style.maxWidth = style.width = ret;
6508			ret = computed.width;
6509
6510			// Revert the changed values
6511			style.width = width;
6512			style.minWidth = minWidth;
6513			style.maxWidth = maxWidth;
6514		}
6515	}
6516
6517	return ret !== undefined ?
6518
6519		// Support: IE <=9 - 11 only
6520		// IE returns zIndex value as an integer.
6521		ret + "" :
6522		ret;
6523}
6524
6525
6526function addGetHookIf( conditionFn, hookFn ) {
6527
6528	// Define the hook, we'll check on the first run if it's really needed.
6529	return {
6530		get: function() {
6531			if ( conditionFn() ) {
6532
6533				// Hook not needed (or it's not possible to use it due
6534				// to missing dependency), remove it.
6535				delete this.get;
6536				return;
6537			}
6538
6539			// Hook needed; redefine it so that the support test is not executed again.
6540			return ( this.get = hookFn ).apply( this, arguments );
6541		}
6542	};
6543}
6544
6545
6546var cssPrefixes = [ "Webkit", "Moz", "ms" ],
6547	emptyStyle = document.createElement( "div" ).style,
6548	vendorProps = {};
6549
6550// Return a vendor-prefixed property or undefined
6551function vendorPropName( name ) {
6552
6553	// Check for vendor prefixed names
6554	var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
6555		i = cssPrefixes.length;
6556
6557	while ( i-- ) {
6558		name = cssPrefixes[ i ] + capName;
6559		if ( name in emptyStyle ) {
6560			return name;
6561		}
6562	}
6563}
6564
6565// Return a potentially-mapped jQuery.cssProps or vendor prefixed property
6566function finalPropName( name ) {
6567	var final = jQuery.cssProps[ name ] || vendorProps[ name ];
6568
6569	if ( final ) {
6570		return final;
6571	}
6572	if ( name in emptyStyle ) {
6573		return name;
6574	}
6575	return vendorProps[ name ] = vendorPropName( name ) || name;
6576}
6577
6578
6579var
6580
6581	// Swappable if display is none or starts with table
6582	// except "table", "table-cell", or "table-caption"
6583	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
6584	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
6585	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
6586	cssNormalTransform = {
6587		letterSpacing: "0",
6588		fontWeight: "400"
6589	};
6590
6591function setPositiveNumber( _elem, value, subtract ) {
6592
6593	// Any relative (+/-) values have already been
6594	// normalized at this point
6595	var matches = rcssNum.exec( value );
6596	return matches ?
6597
6598		// Guard against undefined "subtract", e.g., when used as in cssHooks
6599		Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
6600		value;
6601}
6602
6603function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
6604	var i = dimension === "width" ? 1 : 0,
6605		extra = 0,
6606		delta = 0,
6607		marginDelta = 0;
6608
6609	// Adjustment may not be necessary
6610	if ( box === ( isBorderBox ? "border" : "content" ) ) {
6611		return 0;
6612	}
6613
6614	for ( ; i < 4; i += 2 ) {
6615
6616		// Both box models exclude margin
6617		// Count margin delta separately to only add it after scroll gutter adjustment.
6618		// This is needed to make negative margins work with `outerHeight( true )` (gh-3982).
6619		if ( box === "margin" ) {
6620			marginDelta += jQuery.css( elem, box + cssExpand[ i ], true, styles );
6621		}
6622
6623		// If we get here with a content-box, we're seeking "padding" or "border" or "margin"
6624		if ( !isBorderBox ) {
6625
6626			// Add padding
6627			delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6628
6629			// For "border" or "margin", add border
6630			if ( box !== "padding" ) {
6631				delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6632
6633			// But still keep track of it otherwise
6634			} else {
6635				extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6636			}
6637
6638		// If we get here with a border-box (content + padding + border), we're seeking "content" or
6639		// "padding" or "margin"
6640		} else {
6641
6642			// For "content", subtract padding
6643			if ( box === "content" ) {
6644				delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6645			}
6646
6647			// For "content" or "padding", subtract border
6648			if ( box !== "margin" ) {
6649				delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6650			}
6651		}
6652	}
6653
6654	// Account for positive content-box scroll gutter when requested by providing computedVal
6655	if ( !isBorderBox && computedVal >= 0 ) {
6656
6657		// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
6658		// Assuming integer scroll gutter, subtract the rest and round down
6659		delta += Math.max( 0, Math.ceil(
6660			elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
6661			computedVal -
6662			delta -
6663			extra -
6664			0.5
6665
6666		// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter
6667		// Use an explicit zero to avoid NaN (gh-3964)
6668		) ) || 0;
6669	}
6670
6671	return delta + marginDelta;
6672}
6673
6674function getWidthOrHeight( elem, dimension, extra ) {
6675
6676	// Start with computed style
6677	var styles = getStyles( elem ),
6678
6679		// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).
6680		// Fake content-box until we know it's needed to know the true value.
6681		boxSizingNeeded = !support.boxSizingReliable() || extra,
6682		isBorderBox = boxSizingNeeded &&
6683			jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
6684		valueIsBorderBox = isBorderBox,
6685
6686		val = curCSS( elem, dimension, styles ),
6687		offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );
6688
6689	// Support: Firefox <=54
6690	// Return a confounding non-pixel value or feign ignorance, as appropriate.
6691	if ( rnumnonpx.test( val ) ) {
6692		if ( !extra ) {
6693			return val;
6694		}
6695		val = "auto";
6696	}
6697
6698
6699	// Support: IE 9 - 11 only
6700	// Use offsetWidth/offsetHeight for when box sizing is unreliable.
6701	// In those cases, the computed value can be trusted to be border-box.
6702	if ( ( !support.boxSizingReliable() && isBorderBox ||
6703
6704		// Support: IE 10 - 11+, Edge 15 - 18+
6705		// IE/Edge misreport `getComputedStyle` of table rows with width/height
6706		// set in CSS while `offset*` properties report correct values.
6707		// Interestingly, in some cases IE 9 doesn't suffer from this issue.
6708		!support.reliableTrDimensions() && nodeName( elem, "tr" ) ||
6709
6710		// Fall back to offsetWidth/offsetHeight when value is "auto"
6711		// This happens for inline elements with no explicit setting (gh-3571)
6712		val === "auto" ||
6713
6714		// Support: Android <=4.1 - 4.3 only
6715		// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
6716		!parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) &&
6717
6718		// Make sure the element is visible & connected
6719		elem.getClientRects().length ) {
6720
6721		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
6722
6723		// Where available, offsetWidth/offsetHeight approximate border box dimensions.
6724		// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the
6725		// retrieved value as a content box dimension.
6726		valueIsBorderBox = offsetProp in elem;
6727		if ( valueIsBorderBox ) {
6728			val = elem[ offsetProp ];
6729		}
6730	}
6731
6732	// Normalize "" and auto
6733	val = parseFloat( val ) || 0;
6734
6735	// Adjust for the element's box model
6736	return ( val +
6737		boxModelAdjustment(
6738			elem,
6739			dimension,
6740			extra || ( isBorderBox ? "border" : "content" ),
6741			valueIsBorderBox,
6742			styles,
6743
6744			// Provide the current computed size to request scroll gutter calculation (gh-3589)
6745			val
6746		)
6747	) + "px";
6748}
6749
6750jQuery.extend( {
6751
6752	// Add in style property hooks for overriding the default
6753	// behavior of getting and setting a style property
6754	cssHooks: {
6755		opacity: {
6756			get: function( elem, computed ) {
6757				if ( computed ) {
6758
6759					// We should always get a number back from opacity
6760					var ret = curCSS( elem, "opacity" );
6761					return ret === "" ? "1" : ret;
6762				}
6763			}
6764		}
6765	},
6766
6767	// Don't automatically add "px" to these possibly-unitless properties
6768	cssNumber: {
6769		animationIterationCount: true,
6770		aspectRatio: true,
6771		borderImageSlice: true,
6772		columnCount: true,
6773		flexGrow: true,
6774		flexShrink: true,
6775		fontWeight: true,
6776		gridArea: true,
6777		gridColumn: true,
6778		gridColumnEnd: true,
6779		gridColumnStart: true,
6780		gridRow: true,
6781		gridRowEnd: true,
6782		gridRowStart: true,
6783		lineHeight: true,
6784		opacity: true,
6785		order: true,
6786		orphans: true,
6787		scale: true,
6788		widows: true,
6789		zIndex: true,
6790		zoom: true,
6791
6792		// SVG-related
6793		fillOpacity: true,
6794		floodOpacity: true,
6795		stopOpacity: true,
6796		strokeMiterlimit: true,
6797		strokeOpacity: true
6798	},
6799
6800	// Add in properties whose names you wish to fix before
6801	// setting or getting the value
6802	cssProps: {},
6803
6804	// Get and set the style property on a DOM Node
6805	style: function( elem, name, value, extra ) {
6806
6807		// Don't set styles on text and comment nodes
6808		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
6809			return;
6810		}
6811
6812		// Make sure that we're working with the right name
6813		var ret, type, hooks,
6814			origName = camelCase( name ),
6815			isCustomProp = rcustomProp.test( name ),
6816			style = elem.style;
6817
6818		// Make sure that we're working with the right name. We don't
6819		// want to query the value if it is a CSS custom property
6820		// since they are user-defined.
6821		if ( !isCustomProp ) {
6822			name = finalPropName( origName );
6823		}
6824
6825		// Gets hook for the prefixed version, then unprefixed version
6826		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6827
6828		// Check if we're setting a value
6829		if ( value !== undefined ) {
6830			type = typeof value;
6831
6832			// Convert "+=" or "-=" to relative numbers (trac-7345)
6833			if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
6834				value = adjustCSS( elem, name, ret );
6835
6836				// Fixes bug trac-9237
6837				type = "number";
6838			}
6839
6840			// Make sure that null and NaN values aren't set (trac-7116)
6841			if ( value == null || value !== value ) {
6842				return;
6843			}
6844
6845			// If a number was passed in, add the unit (except for certain CSS properties)
6846			// The isCustomProp check can be removed in jQuery 4.0 when we only auto-append
6847			// "px" to a few hardcoded values.
6848			if ( type === "number" && !isCustomProp ) {
6849				value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
6850			}
6851
6852			// background-* props affect original clone's values
6853			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
6854				style[ name ] = "inherit";
6855			}
6856
6857			// If a hook was provided, use that value, otherwise just set the specified value
6858			if ( !hooks || !( "set" in hooks ) ||
6859				( value = hooks.set( elem, value, extra ) ) !== undefined ) {
6860
6861				if ( isCustomProp ) {
6862					style.setProperty( name, value );
6863				} else {
6864					style[ name ] = value;
6865				}
6866			}
6867
6868		} else {
6869
6870			// If a hook was provided get the non-computed value from there
6871			if ( hooks && "get" in hooks &&
6872				( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
6873
6874				return ret;
6875			}
6876
6877			// Otherwise just get the value from the style object
6878			return style[ name ];
6879		}
6880	},
6881
6882	css: function( elem, name, extra, styles ) {
6883		var val, num, hooks,
6884			origName = camelCase( name ),
6885			isCustomProp = rcustomProp.test( name );
6886
6887		// Make sure that we're working with the right name. We don't
6888		// want to modify the value if it is a CSS custom property
6889		// since they are user-defined.
6890		if ( !isCustomProp ) {
6891			name = finalPropName( origName );
6892		}
6893
6894		// Try prefixed name followed by the unprefixed name
6895		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6896
6897		// If a hook was provided get the computed value from there
6898		if ( hooks && "get" in hooks ) {
6899			val = hooks.get( elem, true, extra );
6900		}
6901
6902		// Otherwise, if a way to get the computed value exists, use that
6903		if ( val === undefined ) {
6904			val = curCSS( elem, name, styles );
6905		}
6906
6907		// Convert "normal" to computed value
6908		if ( val === "normal" && name in cssNormalTransform ) {
6909			val = cssNormalTransform[ name ];
6910		}
6911
6912		// Make numeric if forced or a qualifier was provided and val looks numeric
6913		if ( extra === "" || extra ) {
6914			num = parseFloat( val );
6915			return extra === true || isFinite( num ) ? num || 0 : val;
6916		}
6917
6918		return val;
6919	}
6920} );
6921
6922jQuery.each( [ "height", "width" ], function( _i, dimension ) {
6923	jQuery.cssHooks[ dimension ] = {
6924		get: function( elem, computed, extra ) {
6925			if ( computed ) {
6926
6927				// Certain elements can have dimension info if we invisibly show them
6928				// but it must have a current display style that would benefit
6929				return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
6930
6931					// Support: Safari 8+
6932					// Table columns in Safari have non-zero offsetWidth & zero
6933					// getBoundingClientRect().width unless display is changed.
6934					// Support: IE <=11 only
6935					// Running getBoundingClientRect on a disconnected node
6936					// in IE throws an error.
6937					( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
6938					swap( elem, cssShow, function() {
6939						return getWidthOrHeight( elem, dimension, extra );
6940					} ) :
6941					getWidthOrHeight( elem, dimension, extra );
6942			}
6943		},
6944
6945		set: function( elem, value, extra ) {
6946			var matches,
6947				styles = getStyles( elem ),
6948
6949				// Only read styles.position if the test has a chance to fail
6950				// to avoid forcing a reflow.
6951				scrollboxSizeBuggy = !support.scrollboxSize() &&
6952					styles.position === "absolute",
6953
6954				// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)
6955				boxSizingNeeded = scrollboxSizeBuggy || extra,
6956				isBorderBox = boxSizingNeeded &&
6957					jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
6958				subtract = extra ?
6959					boxModelAdjustment(
6960						elem,
6961						dimension,
6962						extra,
6963						isBorderBox,
6964						styles
6965					) :
6966					0;
6967
6968			// Account for unreliable border-box dimensions by comparing offset* to computed and
6969			// faking a content-box to get border and padding (gh-3699)
6970			if ( isBorderBox && scrollboxSizeBuggy ) {
6971				subtract -= Math.ceil(
6972					elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
6973					parseFloat( styles[ dimension ] ) -
6974					boxModelAdjustment( elem, dimension, "border", false, styles ) -
6975					0.5
6976				);
6977			}
6978
6979			// Convert to pixels if value adjustment is needed
6980			if ( subtract && ( matches = rcssNum.exec( value ) ) &&
6981				( matches[ 3 ] || "px" ) !== "px" ) {
6982
6983				elem.style[ dimension ] = value;
6984				value = jQuery.css( elem, dimension );
6985			}
6986
6987			return setPositiveNumber( elem, value, subtract );
6988		}
6989	};
6990} );
6991
6992jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
6993	function( elem, computed ) {
6994		if ( computed ) {
6995			return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
6996				elem.getBoundingClientRect().left -
6997					swap( elem, { marginLeft: 0 }, function() {
6998						return elem.getBoundingClientRect().left;
6999					} )
7000			) + "px";
7001		}
7002	}
7003);
7004
7005// These hooks are used by animate to expand properties
7006jQuery.each( {
7007	margin: "",
7008	padding: "",
7009	border: "Width"
7010}, function( prefix, suffix ) {
7011	jQuery.cssHooks[ prefix + suffix ] = {
7012		expand: function( value ) {
7013			var i = 0,
7014				expanded = {},
7015
7016				// Assumes a single number if not a string
7017				parts = typeof value === "string" ? value.split( " " ) : [ value ];
7018
7019			for ( ; i < 4; i++ ) {
7020				expanded[ prefix + cssExpand[ i ] + suffix ] =
7021					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
7022			}
7023
7024			return expanded;
7025		}
7026	};
7027
7028	if ( prefix !== "margin" ) {
7029		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
7030	}
7031} );
7032
7033jQuery.fn.extend( {
7034	css: function( name, value ) {
7035		return access( this, function( elem, name, value ) {
7036			var styles, len,
7037				map = {},
7038				i = 0;
7039
7040			if ( Array.isArray( name ) ) {
7041				styles = getStyles( elem );
7042				len = name.length;
7043
7044				for ( ; i < len; i++ ) {
7045					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
7046				}
7047
7048				return map;
7049			}
7050
7051			return value !== undefined ?
7052				jQuery.style( elem, name, value ) :
7053				jQuery.css( elem, name );
7054		}, name, value, arguments.length > 1 );
7055	}
7056} );
7057
7058
7059function Tween( elem, options, prop, end, easing ) {
7060	return new Tween.prototype.init( elem, options, prop, end, easing );
7061}
7062jQuery.Tween = Tween;
7063
7064Tween.prototype = {
7065	constructor: Tween,
7066	init: function( elem, options, prop, end, easing, unit ) {
7067		this.elem = elem;
7068		this.prop = prop;
7069		this.easing = easing || jQuery.easing._default;
7070		this.options = options;
7071		this.start = this.now = this.cur();
7072		this.end = end;
7073		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
7074	},
7075	cur: function() {
7076		var hooks = Tween.propHooks[ this.prop ];
7077
7078		return hooks && hooks.get ?
7079			hooks.get( this ) :
7080			Tween.propHooks._default.get( this );
7081	},
7082	run: function( percent ) {
7083		var eased,
7084			hooks = Tween.propHooks[ this.prop ];
7085
7086		if ( this.options.duration ) {
7087			this.pos = eased = jQuery.easing[ this.easing ](
7088				percent, this.options.duration * percent, 0, 1, this.options.duration
7089			);
7090		} else {
7091			this.pos = eased = percent;
7092		}
7093		this.now = ( this.end - this.start ) * eased + this.start;
7094
7095		if ( this.options.step ) {
7096			this.options.step.call( this.elem, this.now, this );
7097		}
7098
7099		if ( hooks && hooks.set ) {
7100			hooks.set( this );
7101		} else {
7102			Tween.propHooks._default.set( this );
7103		}
7104		return this;
7105	}
7106};
7107
7108Tween.prototype.init.prototype = Tween.prototype;
7109
7110Tween.propHooks = {
7111	_default: {
7112		get: function( tween ) {
7113			var result;
7114
7115			// Use a property on the element directly when it is not a DOM element,
7116			// or when there is no matching style property that exists.
7117			if ( tween.elem.nodeType !== 1 ||
7118				tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
7119				return tween.elem[ tween.prop ];
7120			}
7121
7122			// Passing an empty string as a 3rd parameter to .css will automatically
7123			// attempt a parseFloat and fallback to a string if the parse fails.
7124			// Simple values such as "10px" are parsed to Float;
7125			// complex values such as "rotate(1rad)" are returned as-is.
7126			result = jQuery.css( tween.elem, tween.prop, "" );
7127
7128			// Empty strings, null, undefined and "auto" are converted to 0.
7129			return !result || result === "auto" ? 0 : result;
7130		},
7131		set: function( tween ) {
7132
7133			// Use step hook for back compat.
7134			// Use cssHook if its there.
7135			// Use .style if available and use plain properties where available.
7136			if ( jQuery.fx.step[ tween.prop ] ) {
7137				jQuery.fx.step[ tween.prop ]( tween );
7138			} else if ( tween.elem.nodeType === 1 && (
7139				jQuery.cssHooks[ tween.prop ] ||
7140					tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {
7141				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
7142			} else {
7143				tween.elem[ tween.prop ] = tween.now;
7144			}
7145		}
7146	}
7147};
7148
7149// Support: IE <=9 only
7150// Panic based approach to setting things on disconnected nodes
7151Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
7152	set: function( tween ) {
7153		if ( tween.elem.nodeType && tween.elem.parentNode ) {
7154			tween.elem[ tween.prop ] = tween.now;
7155		}
7156	}
7157};
7158
7159jQuery.easing = {
7160	linear: function( p ) {
7161		return p;
7162	},
7163	swing: function( p ) {
7164		return 0.5 - Math.cos( p * Math.PI ) / 2;
7165	},
7166	_default: "swing"
7167};
7168
7169jQuery.fx = Tween.prototype.init;
7170
7171// Back compat <1.8 extension point
7172jQuery.fx.step = {};
7173
7174
7175
7176
7177var
7178	fxNow, inProgress,
7179	rfxtypes = /^(?:toggle|show|hide)$/,
7180	rrun = /queueHooks$/;
7181
7182function schedule() {
7183	if ( inProgress ) {
7184		if ( document.hidden === false && window.requestAnimationFrame ) {
7185			window.requestAnimationFrame( schedule );
7186		} else {
7187			window.setTimeout( schedule, jQuery.fx.interval );
7188		}
7189
7190		jQuery.fx.tick();
7191	}
7192}
7193
7194// Animations created synchronously will run synchronously
7195function createFxNow() {
7196	window.setTimeout( function() {
7197		fxNow = undefined;
7198	} );
7199	return ( fxNow = Date.now() );
7200}
7201
7202// Generate parameters to create a standard animation
7203function genFx( type, includeWidth ) {
7204	var which,
7205		i = 0,
7206		attrs = { height: type };
7207
7208	// If we include width, step value is 1 to do all cssExpand values,
7209	// otherwise step value is 2 to skip over Left and Right
7210	includeWidth = includeWidth ? 1 : 0;
7211	for ( ; i < 4; i += 2 - includeWidth ) {
7212		which = cssExpand[ i ];
7213		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
7214	}
7215
7216	if ( includeWidth ) {
7217		attrs.opacity = attrs.width = type;
7218	}
7219
7220	return attrs;
7221}
7222
7223function createTween( value, prop, animation ) {
7224	var tween,
7225		collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
7226		index = 0,
7227		length = collection.length;
7228	for ( ; index < length; index++ ) {
7229		if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
7230
7231			// We're done with this property
7232			return tween;
7233		}
7234	}
7235}
7236
7237function defaultPrefilter( elem, props, opts ) {
7238	var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
7239		isBox = "width" in props || "height" in props,
7240		anim = this,
7241		orig = {},
7242		style = elem.style,
7243		hidden = elem.nodeType && isHiddenWithinTree( elem ),
7244		dataShow = dataPriv.get( elem, "fxshow" );
7245
7246	// Queue-skipping animations hijack the fx hooks
7247	if ( !opts.queue ) {
7248		hooks = jQuery._queueHooks( elem, "fx" );
7249		if ( hooks.unqueued == null ) {
7250			hooks.unqueued = 0;
7251			oldfire = hooks.empty.fire;
7252			hooks.empty.fire = function() {
7253				if ( !hooks.unqueued ) {
7254					oldfire();
7255				}
7256			};
7257		}
7258		hooks.unqueued++;
7259
7260		anim.always( function() {
7261
7262			// Ensure the complete handler is called before this completes
7263			anim.always( function() {
7264				hooks.unqueued--;
7265				if ( !jQuery.queue( elem, "fx" ).length ) {
7266					hooks.empty.fire();
7267				}
7268			} );
7269		} );
7270	}
7271
7272	// Detect show/hide animations
7273	for ( prop in props ) {
7274		value = props[ prop ];
7275		if ( rfxtypes.test( value ) ) {
7276			delete props[ prop ];
7277			toggle = toggle || value === "toggle";
7278			if ( value === ( hidden ? "hide" : "show" ) ) {
7279
7280				// Pretend to be hidden if this is a "show" and
7281				// there is still data from a stopped show/hide
7282				if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
7283					hidden = true;
7284
7285				// Ignore all other no-op show/hide data
7286				} else {
7287					continue;
7288				}
7289			}
7290			orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
7291		}
7292	}
7293
7294	// Bail out if this is a no-op like .hide().hide()
7295	propTween = !jQuery.isEmptyObject( props );
7296	if ( !propTween && jQuery.isEmptyObject( orig ) ) {
7297		return;
7298	}
7299
7300	// Restrict "overflow" and "display" styles during box animations
7301	if ( isBox && elem.nodeType === 1 ) {
7302
7303		// Support: IE <=9 - 11, Edge 12 - 15
7304		// Record all 3 overflow attributes because IE does not infer the shorthand
7305		// from identically-valued overflowX and overflowY and Edge just mirrors
7306		// the overflowX value there.
7307		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
7308
7309		// Identify a display type, preferring old show/hide data over the CSS cascade
7310		restoreDisplay = dataShow && dataShow.display;
7311		if ( restoreDisplay == null ) {
7312			restoreDisplay = dataPriv.get( elem, "display" );
7313		}
7314		display = jQuery.css( elem, "display" );
7315		if ( display === "none" ) {
7316			if ( restoreDisplay ) {
7317				display = restoreDisplay;
7318			} else {
7319
7320				// Get nonempty value(s) by temporarily forcing visibility
7321				showHide( [ elem ], true );
7322				restoreDisplay = elem.style.display || restoreDisplay;
7323				display = jQuery.css( elem, "display" );
7324				showHide( [ elem ] );
7325			}
7326		}
7327
7328		// Animate inline elements as inline-block
7329		if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
7330			if ( jQuery.css( elem, "float" ) === "none" ) {
7331
7332				// Restore the original display value at the end of pure show/hide animations
7333				if ( !propTween ) {
7334					anim.done( function() {
7335						style.display = restoreDisplay;
7336					} );
7337					if ( restoreDisplay == null ) {
7338						display = style.display;
7339						restoreDisplay = display === "none" ? "" : display;
7340					}
7341				}
7342				style.display = "inline-block";
7343			}
7344		}
7345	}
7346
7347	if ( opts.overflow ) {
7348		style.overflow = "hidden";
7349		anim.always( function() {
7350			style.overflow = opts.overflow[ 0 ];
7351			style.overflowX = opts.overflow[ 1 ];
7352			style.overflowY = opts.overflow[ 2 ];
7353		} );
7354	}
7355
7356	// Implement show/hide animations
7357	propTween = false;
7358	for ( prop in orig ) {
7359
7360		// General show/hide setup for this element animation
7361		if ( !propTween ) {
7362			if ( dataShow ) {
7363				if ( "hidden" in dataShow ) {
7364					hidden = dataShow.hidden;
7365				}
7366			} else {
7367				dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
7368			}
7369
7370			// Store hidden/visible for toggle so `.stop().toggle()` "reverses"
7371			if ( toggle ) {
7372				dataShow.hidden = !hidden;
7373			}
7374
7375			// Show elements before animating them
7376			if ( hidden ) {
7377				showHide( [ elem ], true );
7378			}
7379
7380			/* eslint-disable no-loop-func */
7381
7382			anim.done( function() {
7383
7384				/* eslint-enable no-loop-func */
7385
7386				// The final step of a "hide" animation is actually hiding the element
7387				if ( !hidden ) {
7388					showHide( [ elem ] );
7389				}
7390				dataPriv.remove( elem, "fxshow" );
7391				for ( prop in orig ) {
7392					jQuery.style( elem, prop, orig[ prop ] );
7393				}
7394			} );
7395		}
7396
7397		// Per-property setup
7398		propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
7399		if ( !( prop in dataShow ) ) {
7400			dataShow[ prop ] = propTween.start;
7401			if ( hidden ) {
7402				propTween.end = propTween.start;
7403				propTween.start = 0;
7404			}
7405		}
7406	}
7407}
7408
7409function propFilter( props, specialEasing ) {
7410	var index, name, easing, value, hooks;
7411
7412	// camelCase, specialEasing and expand cssHook pass
7413	for ( index in props ) {
7414		name = camelCase( index );
7415		easing = specialEasing[ name ];
7416		value = props[ index ];
7417		if ( Array.isArray( value ) ) {
7418			easing = value[ 1 ];
7419			value = props[ index ] = value[ 0 ];
7420		}
7421
7422		if ( index !== name ) {
7423			props[ name ] = value;
7424			delete props[ index ];
7425		}
7426
7427		hooks = jQuery.cssHooks[ name ];
7428		if ( hooks && "expand" in hooks ) {
7429			value = hooks.expand( value );
7430			delete props[ name ];
7431
7432			// Not quite $.extend, this won't overwrite existing keys.
7433			// Reusing 'index' because we have the correct "name"
7434			for ( index in value ) {
7435				if ( !( index in props ) ) {
7436					props[ index ] = value[ index ];
7437					specialEasing[ index ] = easing;
7438				}
7439			}
7440		} else {
7441			specialEasing[ name ] = easing;
7442		}
7443	}
7444}
7445
7446function Animation( elem, properties, options ) {
7447	var result,
7448		stopped,
7449		index = 0,
7450		length = Animation.prefilters.length,
7451		deferred = jQuery.Deferred().always( function() {
7452
7453			// Don't match elem in the :animated selector
7454			delete tick.elem;
7455		} ),
7456		tick = function() {
7457			if ( stopped ) {
7458				return false;
7459			}
7460			var currentTime = fxNow || createFxNow(),
7461				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
7462
7463				// Support: Android 2.3 only
7464				// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (trac-12497)
7465				temp = remaining / animation.duration || 0,
7466				percent = 1 - temp,
7467				index = 0,
7468				length = animation.tweens.length;
7469
7470			for ( ; index < length; index++ ) {
7471				animation.tweens[ index ].run( percent );
7472			}
7473
7474			deferred.notifyWith( elem, [ animation, percent, remaining ] );
7475
7476			// If there's more to do, yield
7477			if ( percent < 1 && length ) {
7478				return remaining;
7479			}
7480
7481			// If this was an empty animation, synthesize a final progress notification
7482			if ( !length ) {
7483				deferred.notifyWith( elem, [ animation, 1, 0 ] );
7484			}
7485
7486			// Resolve the animation and report its conclusion
7487			deferred.resolveWith( elem, [ animation ] );
7488			return false;
7489		},
7490		animation = deferred.promise( {
7491			elem: elem,
7492			props: jQuery.extend( {}, properties ),
7493			opts: jQuery.extend( true, {
7494				specialEasing: {},
7495				easing: jQuery.easing._default
7496			}, options ),
7497			originalProperties: properties,
7498			originalOptions: options,
7499			startTime: fxNow || createFxNow(),
7500			duration: options.duration,
7501			tweens: [],
7502			createTween: function( prop, end ) {
7503				var tween = jQuery.Tween( elem, animation.opts, prop, end,
7504					animation.opts.specialEasing[ prop ] || animation.opts.easing );
7505				animation.tweens.push( tween );
7506				return tween;
7507			},
7508			stop: function( gotoEnd ) {
7509				var index = 0,
7510
7511					// If we are going to the end, we want to run all the tweens
7512					// otherwise we skip this part
7513					length = gotoEnd ? animation.tweens.length : 0;
7514				if ( stopped ) {
7515					return this;
7516				}
7517				stopped = true;
7518				for ( ; index < length; index++ ) {
7519					animation.tweens[ index ].run( 1 );
7520				}
7521
7522				// Resolve when we played the last frame; otherwise, reject
7523				if ( gotoEnd ) {
7524					deferred.notifyWith( elem, [ animation, 1, 0 ] );
7525					deferred.resolveWith( elem, [ animation, gotoEnd ] );
7526				} else {
7527					deferred.rejectWith( elem, [ animation, gotoEnd ] );
7528				}
7529				return this;
7530			}
7531		} ),
7532		props = animation.props;
7533
7534	propFilter( props, animation.opts.specialEasing );
7535
7536	for ( ; index < length; index++ ) {
7537		result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
7538		if ( result ) {
7539			if ( isFunction( result.stop ) ) {
7540				jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
7541					result.stop.bind( result );
7542			}
7543			return result;
7544		}
7545	}
7546
7547	jQuery.map( props, createTween, animation );
7548
7549	if ( isFunction( animation.opts.start ) ) {
7550		animation.opts.start.call( elem, animation );
7551	}
7552
7553	// Attach callbacks from options
7554	animation
7555		.progress( animation.opts.progress )
7556		.done( animation.opts.done, animation.opts.complete )
7557		.fail( animation.opts.fail )
7558		.always( animation.opts.always );
7559
7560	jQuery.fx.timer(
7561		jQuery.extend( tick, {
7562			elem: elem,
7563			anim: animation,
7564			queue: animation.opts.queue
7565		} )
7566	);
7567
7568	return animation;
7569}
7570
7571jQuery.Animation = jQuery.extend( Animation, {
7572
7573	tweeners: {
7574		"*": [ function( prop, value ) {
7575			var tween = this.createTween( prop, value );
7576			adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
7577			return tween;
7578		} ]
7579	},
7580
7581	tweener: function( props, callback ) {
7582		if ( isFunction( props ) ) {
7583			callback = props;
7584			props = [ "*" ];
7585		} else {
7586			props = props.match( rnothtmlwhite );
7587		}
7588
7589		var prop,
7590			index = 0,
7591			length = props.length;
7592
7593		for ( ; index < length; index++ ) {
7594			prop = props[ index ];
7595			Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
7596			Animation.tweeners[ prop ].unshift( callback );
7597		}
7598	},
7599
7600	prefilters: [ defaultPrefilter ],
7601
7602	prefilter: function( callback, prepend ) {
7603		if ( prepend ) {
7604			Animation.prefilters.unshift( callback );
7605		} else {
7606			Animation.prefilters.push( callback );
7607		}
7608	}
7609} );
7610
7611jQuery.speed = function( speed, easing, fn ) {
7612	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
7613		complete: fn || !fn && easing ||
7614			isFunction( speed ) && speed,
7615		duration: speed,
7616		easing: fn && easing || easing && !isFunction( easing ) && easing
7617	};
7618
7619	// Go to the end state if fx are off
7620	if ( jQuery.fx.off ) {
7621		opt.duration = 0;
7622
7623	} else {
7624		if ( typeof opt.duration !== "number" ) {
7625			if ( opt.duration in jQuery.fx.speeds ) {
7626				opt.duration = jQuery.fx.speeds[ opt.duration ];
7627
7628			} else {
7629				opt.duration = jQuery.fx.speeds._default;
7630			}
7631		}
7632	}
7633
7634	// Normalize opt.queue - true/undefined/null -> "fx"
7635	if ( opt.queue == null || opt.queue === true ) {
7636		opt.queue = "fx";
7637	}
7638
7639	// Queueing
7640	opt.old = opt.complete;
7641
7642	opt.complete = function() {
7643		if ( isFunction( opt.old ) ) {
7644			opt.old.call( this );
7645		}
7646
7647		if ( opt.queue ) {
7648			jQuery.dequeue( this, opt.queue );
7649		}
7650	};
7651
7652	return opt;
7653};
7654
7655jQuery.fn.extend( {
7656	fadeTo: function( speed, to, easing, callback ) {
7657
7658		// Show any hidden elements after setting opacity to 0
7659		return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
7660
7661			// Animate to the value specified
7662			.end().animate( { opacity: to }, speed, easing, callback );
7663	},
7664	animate: function( prop, speed, easing, callback ) {
7665		var empty = jQuery.isEmptyObject( prop ),
7666			optall = jQuery.speed( speed, easing, callback ),
7667			doAnimation = function() {
7668
7669				// Operate on a copy of prop so per-property easing won't be lost
7670				var anim = Animation( this, jQuery.extend( {}, prop ), optall );
7671
7672				// Empty animations, or finishing resolves immediately
7673				if ( empty || dataPriv.get( this, "finish" ) ) {
7674					anim.stop( true );
7675				}
7676			};
7677
7678		doAnimation.finish = doAnimation;
7679
7680		return empty || optall.queue === false ?
7681			this.each( doAnimation ) :
7682			this.queue( optall.queue, doAnimation );
7683	},
7684	stop: function( type, clearQueue, gotoEnd ) {
7685		var stopQueue = function( hooks ) {
7686			var stop = hooks.stop;
7687			delete hooks.stop;
7688			stop( gotoEnd );
7689		};
7690
7691		if ( typeof type !== "string" ) {
7692			gotoEnd = clearQueue;
7693			clearQueue = type;
7694			type = undefined;
7695		}
7696		if ( clearQueue ) {
7697			this.queue( type || "fx", [] );
7698		}
7699
7700		return this.each( function() {
7701			var dequeue = true,
7702				index = type != null && type + "queueHooks",
7703				timers = jQuery.timers,
7704				data = dataPriv.get( this );
7705
7706			if ( index ) {
7707				if ( data[ index ] && data[ index ].stop ) {
7708					stopQueue( data[ index ] );
7709				}
7710			} else {
7711				for ( index in data ) {
7712					if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
7713						stopQueue( data[ index ] );
7714					}
7715				}
7716			}
7717
7718			for ( index = timers.length; index--; ) {
7719				if ( timers[ index ].elem === this &&
7720					( type == null || timers[ index ].queue === type ) ) {
7721
7722					timers[ index ].anim.stop( gotoEnd );
7723					dequeue = false;
7724					timers.splice( index, 1 );
7725				}
7726			}
7727
7728			// Start the next in the queue if the last step wasn't forced.
7729			// Timers currently will call their complete callbacks, which
7730			// will dequeue but only if they were gotoEnd.
7731			if ( dequeue || !gotoEnd ) {
7732				jQuery.dequeue( this, type );
7733			}
7734		} );
7735	},
7736	finish: function( type ) {
7737		if ( type !== false ) {
7738			type = type || "fx";
7739		}
7740		return this.each( function() {
7741			var index,
7742				data = dataPriv.get( this ),
7743				queue = data[ type + "queue" ],
7744				hooks = data[ type + "queueHooks" ],
7745				timers = jQuery.timers,
7746				length = queue ? queue.length : 0;
7747
7748			// Enable finishing flag on private data
7749			data.finish = true;
7750
7751			// Empty the queue first
7752			jQuery.queue( this, type, [] );
7753
7754			if ( hooks && hooks.stop ) {
7755				hooks.stop.call( this, true );
7756			}
7757
7758			// Look for any active animations, and finish them
7759			for ( index = timers.length; index--; ) {
7760				if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
7761					timers[ index ].anim.stop( true );
7762					timers.splice( index, 1 );
7763				}
7764			}
7765
7766			// Look for any animations in the old queue and finish them
7767			for ( index = 0; index < length; index++ ) {
7768				if ( queue[ index ] && queue[ index ].finish ) {
7769					queue[ index ].finish.call( this );
7770				}
7771			}
7772
7773			// Turn off finishing flag
7774			delete data.finish;
7775		} );
7776	}
7777} );
7778
7779jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) {
7780	var cssFn = jQuery.fn[ name ];
7781	jQuery.fn[ name ] = function( speed, easing, callback ) {
7782		return speed == null || typeof speed === "boolean" ?
7783			cssFn.apply( this, arguments ) :
7784			this.animate( genFx( name, true ), speed, easing, callback );
7785	};
7786} );
7787
7788// Generate shortcuts for custom animations
7789jQuery.each( {
7790	slideDown: genFx( "show" ),
7791	slideUp: genFx( "hide" ),
7792	slideToggle: genFx( "toggle" ),
7793	fadeIn: { opacity: "show" },
7794	fadeOut: { opacity: "hide" },
7795	fadeToggle: { opacity: "toggle" }
7796}, function( name, props ) {
7797	jQuery.fn[ name ] = function( speed, easing, callback ) {
7798		return this.animate( props, speed, easing, callback );
7799	};
7800} );
7801
7802jQuery.timers = [];
7803jQuery.fx.tick = function() {
7804	var timer,
7805		i = 0,
7806		timers = jQuery.timers;
7807
7808	fxNow = Date.now();
7809
7810	for ( ; i < timers.length; i++ ) {
7811		timer = timers[ i ];
7812
7813		// Run the timer and safely remove it when done (allowing for external removal)
7814		if ( !timer() && timers[ i ] === timer ) {
7815			timers.splice( i--, 1 );
7816		}
7817	}
7818
7819	if ( !timers.length ) {
7820		jQuery.fx.stop();
7821	}
7822	fxNow = undefined;
7823};
7824
7825jQuery.fx.timer = function( timer ) {
7826	jQuery.timers.push( timer );
7827	jQuery.fx.start();
7828};
7829
7830jQuery.fx.interval = 13;
7831jQuery.fx.start = function() {
7832	if ( inProgress ) {
7833		return;
7834	}
7835
7836	inProgress = true;
7837	schedule();
7838};
7839
7840jQuery.fx.stop = function() {
7841	inProgress = null;
7842};
7843
7844jQuery.fx.speeds = {
7845	slow: 600,
7846	fast: 200,
7847
7848	// Default speed
7849	_default: 400
7850};
7851
7852
7853// Based off of the plugin by Clint Helfers, with permission.
7854jQuery.fn.delay = function( time, type ) {
7855	time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
7856	type = type || "fx";
7857
7858	return this.queue( type, function( next, hooks ) {
7859		var timeout = window.setTimeout( next, time );
7860		hooks.stop = function() {
7861			window.clearTimeout( timeout );
7862		};
7863	} );
7864};
7865
7866
7867( function() {
7868	var input = document.createElement( "input" ),
7869		select = document.createElement( "select" ),
7870		opt = select.appendChild( document.createElement( "option" ) );
7871
7872	input.type = "checkbox";
7873
7874	// Support: Android <=4.3 only
7875	// Default value for a checkbox should be "on"
7876	support.checkOn = input.value !== "";
7877
7878	// Support: IE <=11 only
7879	// Must access selectedIndex to make default options select
7880	support.optSelected = opt.selected;
7881
7882	// Support: IE <=11 only
7883	// An input loses its value after becoming a radio
7884	input = document.createElement( "input" );
7885	input.value = "t";
7886	input.type = "radio";
7887	support.radioValue = input.value === "t";
7888} )();
7889
7890
7891var boolHook,
7892	attrHandle = jQuery.expr.attrHandle;
7893
7894jQuery.fn.extend( {
7895	attr: function( name, value ) {
7896		return access( this, jQuery.attr, name, value, arguments.length > 1 );
7897	},
7898
7899	removeAttr: function( name ) {
7900		return this.each( function() {
7901			jQuery.removeAttr( this, name );
7902		} );
7903	}
7904} );
7905
7906jQuery.extend( {
7907	attr: function( elem, name, value ) {
7908		var ret, hooks,
7909			nType = elem.nodeType;
7910
7911		// Don't get/set attributes on text, comment and attribute nodes
7912		if ( nType === 3 || nType === 8 || nType === 2 ) {
7913			return;
7914		}
7915
7916		// Fallback to prop when attributes are not supported
7917		if ( typeof elem.getAttribute === "undefined" ) {
7918			return jQuery.prop( elem, name, value );
7919		}
7920
7921		// Attribute hooks are determined by the lowercase version
7922		// Grab necessary hook if one is defined
7923		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
7924			hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
7925				( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
7926		}
7927
7928		if ( value !== undefined ) {
7929			if ( value === null ) {
7930				jQuery.removeAttr( elem, name );
7931				return;
7932			}
7933
7934			if ( hooks && "set" in hooks &&
7935				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
7936				return ret;
7937			}
7938
7939			elem.setAttribute( name, value + "" );
7940			return value;
7941		}
7942
7943		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
7944			return ret;
7945		}
7946
7947		ret = jQuery.find.attr( elem, name );
7948
7949		// Non-existent attributes return null, we normalize to undefined
7950		return ret == null ? undefined : ret;
7951	},
7952
7953	attrHooks: {
7954		type: {
7955			set: function( elem, value ) {
7956				if ( !support.radioValue && value === "radio" &&
7957					nodeName( elem, "input" ) ) {
7958					var val = elem.value;
7959					elem.setAttribute( "type", value );
7960					if ( val ) {
7961						elem.value = val;
7962					}
7963					return value;
7964				}
7965			}
7966		}
7967	},
7968
7969	removeAttr: function( elem, value ) {
7970		var name,
7971			i = 0,
7972
7973			// Attribute names can contain non-HTML whitespace characters
7974			// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
7975			attrNames = value && value.match( rnothtmlwhite );
7976
7977		if ( attrNames && elem.nodeType === 1 ) {
7978			while ( ( name = attrNames[ i++ ] ) ) {
7979				elem.removeAttribute( name );
7980			}
7981		}
7982	}
7983} );
7984
7985// Hooks for boolean attributes
7986boolHook = {
7987	set: function( elem, value, name ) {
7988		if ( value === false ) {
7989
7990			// Remove boolean attributes when set to false
7991			jQuery.removeAttr( elem, name );
7992		} else {
7993			elem.setAttribute( name, name );
7994		}
7995		return name;
7996	}
7997};
7998
7999jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) {
8000	var getter = attrHandle[ name ] || jQuery.find.attr;
8001
8002	attrHandle[ name ] = function( elem, name, isXML ) {
8003		var ret, handle,
8004			lowercaseName = name.toLowerCase();
8005
8006		if ( !isXML ) {
8007
8008			// Avoid an infinite loop by temporarily removing this function from the getter
8009			handle = attrHandle[ lowercaseName ];
8010			attrHandle[ lowercaseName ] = ret;
8011			ret = getter( elem, name, isXML ) != null ?
8012				lowercaseName :
8013				null;
8014			attrHandle[ lowercaseName ] = handle;
8015		}
8016		return ret;
8017	};
8018} );
8019
8020
8021
8022
8023var rfocusable = /^(?:input|select|textarea|button)$/i,
8024	rclickable = /^(?:a|area)$/i;
8025
8026jQuery.fn.extend( {
8027	prop: function( name, value ) {
8028		return access( this, jQuery.prop, name, value, arguments.length > 1 );
8029	},
8030
8031	removeProp: function( name ) {
8032		return this.each( function() {
8033			delete this[ jQuery.propFix[ name ] || name ];
8034		} );
8035	}
8036} );
8037
8038jQuery.extend( {
8039	prop: function( elem, name, value ) {
8040		var ret, hooks,
8041			nType = elem.nodeType;
8042
8043		// Don't get/set properties on text, comment and attribute nodes
8044		if ( nType === 3 || nType === 8 || nType === 2 ) {
8045			return;
8046		}
8047
8048		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
8049
8050			// Fix name and attach hooks
8051			name = jQuery.propFix[ name ] || name;
8052			hooks = jQuery.propHooks[ name ];
8053		}
8054
8055		if ( value !== undefined ) {
8056			if ( hooks && "set" in hooks &&
8057				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
8058				return ret;
8059			}
8060
8061			return ( elem[ name ] = value );
8062		}
8063
8064		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
8065			return ret;
8066		}
8067
8068		return elem[ name ];
8069	},
8070
8071	propHooks: {
8072		tabIndex: {
8073			get: function( elem ) {
8074
8075				// Support: IE <=9 - 11 only
8076				// elem.tabIndex doesn't always return the
8077				// correct value when it hasn't been explicitly set
8078				// Use proper attribute retrieval (trac-12072)
8079				var tabindex = jQuery.find.attr( elem, "tabindex" );
8080
8081				if ( tabindex ) {
8082					return parseInt( tabindex, 10 );
8083				}
8084
8085				if (
8086					rfocusable.test( elem.nodeName ) ||
8087					rclickable.test( elem.nodeName ) &&
8088					elem.href
8089				) {
8090					return 0;
8091				}
8092
8093				return -1;
8094			}
8095		}
8096	},
8097
8098	propFix: {
8099		"for": "htmlFor",
8100		"class": "className"
8101	}
8102} );
8103
8104// Support: IE <=11 only
8105// Accessing the selectedIndex property
8106// forces the browser to respect setting selected
8107// on the option
8108// The getter ensures a default option is selected
8109// when in an optgroup
8110// eslint rule "no-unused-expressions" is disabled for this code
8111// since it considers such accessions noop
8112if ( !support.optSelected ) {
8113	jQuery.propHooks.selected = {
8114		get: function( elem ) {
8115
8116			/* eslint no-unused-expressions: "off" */
8117
8118			var parent = elem.parentNode;
8119			if ( parent && parent.parentNode ) {
8120				parent.parentNode.selectedIndex;
8121			}
8122			return null;
8123		},
8124		set: function( elem ) {
8125
8126			/* eslint no-unused-expressions: "off" */
8127
8128			var parent = elem.parentNode;
8129			if ( parent ) {
8130				parent.selectedIndex;
8131
8132				if ( parent.parentNode ) {
8133					parent.parentNode.selectedIndex;
8134				}
8135			}
8136		}
8137	};
8138}
8139
8140jQuery.each( [
8141	"tabIndex",
8142	"readOnly",
8143	"maxLength",
8144	"cellSpacing",
8145	"cellPadding",
8146	"rowSpan",
8147	"colSpan",
8148	"useMap",
8149	"frameBorder",
8150	"contentEditable"
8151], function() {
8152	jQuery.propFix[ this.toLowerCase() ] = this;
8153} );
8154
8155
8156
8157
8158	// Strip and collapse whitespace according to HTML spec
8159	// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
8160	function stripAndCollapse( value ) {
8161		var tokens = value.match( rnothtmlwhite ) || [];
8162		return tokens.join( " " );
8163	}
8164
8165
8166function getClass( elem ) {
8167	return elem.getAttribute && elem.getAttribute( "class" ) || "";
8168}
8169
8170function classesToArray( value ) {
8171	if ( Array.isArray( value ) ) {
8172		return value;
8173	}
8174	if ( typeof value === "string" ) {
8175		return value.match( rnothtmlwhite ) || [];
8176	}
8177	return [];
8178}
8179
8180jQuery.fn.extend( {
8181	addClass: function( value ) {
8182		var classNames, cur, curValue, className, i, finalValue;
8183
8184		if ( isFunction( value ) ) {
8185			return this.each( function( j ) {
8186				jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
8187			} );
8188		}
8189
8190		classNames = classesToArray( value );
8191
8192		if ( classNames.length ) {
8193			return this.each( function() {
8194				curValue = getClass( this );
8195				cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
8196
8197				if ( cur ) {
8198					for ( i = 0; i < classNames.length; i++ ) {
8199						className = classNames[ i ];
8200						if ( cur.indexOf( " " + className + " " ) < 0 ) {
8201							cur += className + " ";
8202						}
8203					}
8204
8205					// Only assign if different to avoid unneeded rendering.
8206					finalValue = stripAndCollapse( cur );
8207					if ( curValue !== finalValue ) {
8208						this.setAttribute( "class", finalValue );
8209					}
8210				}
8211			} );
8212		}
8213
8214		return this;
8215	},
8216
8217	removeClass: function( value ) {
8218		var classNames, cur, curValue, className, i, finalValue;
8219
8220		if ( isFunction( value ) ) {
8221			return this.each( function( j ) {
8222				jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
8223			} );
8224		}
8225
8226		if ( !arguments.length ) {
8227			return this.attr( "class", "" );
8228		}
8229
8230		classNames = classesToArray( value );
8231
8232		if ( classNames.length ) {
8233			return this.each( function() {
8234				curValue = getClass( this );
8235
8236				// This expression is here for better compressibility (see addClass)
8237				cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
8238
8239				if ( cur ) {
8240					for ( i = 0; i < classNames.length; i++ ) {
8241						className = classNames[ i ];
8242
8243						// Remove *all* instances
8244						while ( cur.indexOf( " " + className + " " ) > -1 ) {
8245							cur = cur.replace( " " + className + " ", " " );
8246						}
8247					}
8248
8249					// Only assign if different to avoid unneeded rendering.
8250					finalValue = stripAndCollapse( cur );
8251					if ( curValue !== finalValue ) {
8252						this.setAttribute( "class", finalValue );
8253					}
8254				}
8255			} );
8256		}
8257
8258		return this;
8259	},
8260
8261	toggleClass: function( value, stateVal ) {
8262		var classNames, className, i, self,
8263			type = typeof value,
8264			isValidValue = type === "string" || Array.isArray( value );
8265
8266		if ( isFunction( value ) ) {
8267			return this.each( function( i ) {
8268				jQuery( this ).toggleClass(
8269					value.call( this, i, getClass( this ), stateVal ),
8270					stateVal
8271				);
8272			} );
8273		}
8274
8275		if ( typeof stateVal === "boolean" && isValidValue ) {
8276			return stateVal ? this.addClass( value ) : this.removeClass( value );
8277		}
8278
8279		classNames = classesToArray( value );
8280
8281		return this.each( function() {
8282			if ( isValidValue ) {
8283
8284				// Toggle individual class names
8285				self = jQuery( this );
8286
8287				for ( i = 0; i < classNames.length; i++ ) {
8288					className = classNames[ i ];
8289
8290					// Check each className given, space separated list
8291					if ( self.hasClass( className ) ) {
8292						self.removeClass( className );
8293					} else {
8294						self.addClass( className );
8295					}
8296				}
8297
8298			// Toggle whole class name
8299			} else if ( value === undefined || type === "boolean" ) {
8300				className = getClass( this );
8301				if ( className ) {
8302
8303					// Store className if set
8304					dataPriv.set( this, "__className__", className );
8305				}
8306
8307				// If the element has a class name or if we're passed `false`,
8308				// then remove the whole classname (if there was one, the above saved it).
8309				// Otherwise bring back whatever was previously saved (if anything),
8310				// falling back to the empty string if nothing was stored.
8311				if ( this.setAttribute ) {
8312					this.setAttribute( "class",
8313						className || value === false ?
8314							"" :
8315							dataPriv.get( this, "__className__" ) || ""
8316					);
8317				}
8318			}
8319		} );
8320	},
8321
8322	hasClass: function( selector ) {
8323		var className, elem,
8324			i = 0;
8325
8326		className = " " + selector + " ";
8327		while ( ( elem = this[ i++ ] ) ) {
8328			if ( elem.nodeType === 1 &&
8329				( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
8330				return true;
8331			}
8332		}
8333
8334		return false;
8335	}
8336} );
8337
8338
8339
8340
8341var rreturn = /\r/g;
8342
8343jQuery.fn.extend( {
8344	val: function( value ) {
8345		var hooks, ret, valueIsFunction,
8346			elem = this[ 0 ];
8347
8348		if ( !arguments.length ) {
8349			if ( elem ) {
8350				hooks = jQuery.valHooks[ elem.type ] ||
8351					jQuery.valHooks[ elem.nodeName.toLowerCase() ];
8352
8353				if ( hooks &&
8354					"get" in hooks &&
8355					( ret = hooks.get( elem, "value" ) ) !== undefined
8356				) {
8357					return ret;
8358				}
8359
8360				ret = elem.value;
8361
8362				// Handle most common string cases
8363				if ( typeof ret === "string" ) {
8364					return ret.replace( rreturn, "" );
8365				}
8366
8367				// Handle cases where value is null/undef or number
8368				return ret == null ? "" : ret;
8369			}
8370
8371			return;
8372		}
8373
8374		valueIsFunction = isFunction( value );
8375
8376		return this.each( function( i ) {
8377			var val;
8378
8379			if ( this.nodeType !== 1 ) {
8380				return;
8381			}
8382
8383			if ( valueIsFunction ) {
8384				val = value.call( this, i, jQuery( this ).val() );
8385			} else {
8386				val = value;
8387			}
8388
8389			// Treat null/undefined as ""; convert numbers to string
8390			if ( val == null ) {
8391				val = "";
8392
8393			} else if ( typeof val === "number" ) {
8394				val += "";
8395
8396			} else if ( Array.isArray( val ) ) {
8397				val = jQuery.map( val, function( value ) {
8398					return value == null ? "" : value + "";
8399				} );
8400			}
8401
8402			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
8403
8404			// If set returns undefined, fall back to normal setting
8405			if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
8406				this.value = val;
8407			}
8408		} );
8409	}
8410} );
8411
8412jQuery.extend( {
8413	valHooks: {
8414		option: {
8415			get: function( elem ) {
8416
8417				var val = jQuery.find.attr( elem, "value" );
8418				return val != null ?
8419					val :
8420
8421					// Support: IE <=10 - 11 only
8422					// option.text throws exceptions (trac-14686, trac-14858)
8423					// Strip and collapse whitespace
8424					// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
8425					stripAndCollapse( jQuery.text( elem ) );
8426			}
8427		},
8428		select: {
8429			get: function( elem ) {
8430				var value, option, i,
8431					options = elem.options,
8432					index = elem.selectedIndex,
8433					one = elem.type === "select-one",
8434					values = one ? null : [],
8435					max = one ? index + 1 : options.length;
8436
8437				if ( index < 0 ) {
8438					i = max;
8439
8440				} else {
8441					i = one ? index : 0;
8442				}
8443
8444				// Loop through all the selected options
8445				for ( ; i < max; i++ ) {
8446					option = options[ i ];
8447
8448					// Support: IE <=9 only
8449					// IE8-9 doesn't update selected after form reset (trac-2551)
8450					if ( ( option.selected || i === index ) &&
8451
8452							// Don't return options that are disabled or in a disabled optgroup
8453							!option.disabled &&
8454							( !option.parentNode.disabled ||
8455								!nodeName( option.parentNode, "optgroup" ) ) ) {
8456
8457						// Get the specific value for the option
8458						value = jQuery( option ).val();
8459
8460						// We don't need an array for one selects
8461						if ( one ) {
8462							return value;
8463						}
8464
8465						// Multi-Selects return an array
8466						values.push( value );
8467					}
8468				}
8469
8470				return values;
8471			},
8472
8473			set: function( elem, value ) {
8474				var optionSet, option,
8475					options = elem.options,
8476					values = jQuery.makeArray( value ),
8477					i = options.length;
8478
8479				while ( i-- ) {
8480					option = options[ i ];
8481
8482					/* eslint-disable no-cond-assign */
8483
8484					if ( option.selected =
8485						jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
8486					) {
8487						optionSet = true;
8488					}
8489
8490					/* eslint-enable no-cond-assign */
8491				}
8492
8493				// Force browsers to behave consistently when non-matching value is set
8494				if ( !optionSet ) {
8495					elem.selectedIndex = -1;
8496				}
8497				return values;
8498			}
8499		}
8500	}
8501} );
8502
8503// Radios and checkboxes getter/setter
8504jQuery.each( [ "radio", "checkbox" ], function() {
8505	jQuery.valHooks[ this ] = {
8506		set: function( elem, value ) {
8507			if ( Array.isArray( value ) ) {
8508				return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
8509			}
8510		}
8511	};
8512	if ( !support.checkOn ) {
8513		jQuery.valHooks[ this ].get = function( elem ) {
8514			return elem.getAttribute( "value" ) === null ? "on" : elem.value;
8515		};
8516	}
8517} );
8518
8519
8520
8521
8522// Return jQuery for attributes-only inclusion
8523var location = window.location;
8524
8525var nonce = { guid: Date.now() };
8526
8527var rquery = ( /\?/ );
8528
8529
8530
8531// Cross-browser xml parsing
8532jQuery.parseXML = function( data ) {
8533	var xml, parserErrorElem;
8534	if ( !data || typeof data !== "string" ) {
8535		return null;
8536	}
8537
8538	// Support: IE 9 - 11 only
8539	// IE throws on parseFromString with invalid input.
8540	try {
8541		xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
8542	} catch ( e ) {}
8543
8544	parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ];
8545	if ( !xml || parserErrorElem ) {
8546		jQuery.error( "Invalid XML: " + (
8547			parserErrorElem ?
8548				jQuery.map( parserErrorElem.childNodes, function( el ) {
8549					return el.textContent;
8550				} ).join( "\n" ) :
8551				data
8552		) );
8553	}
8554	return xml;
8555};
8556
8557
8558var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
8559	stopPropagationCallback = function( e ) {
8560		e.stopPropagation();
8561	};
8562
8563jQuery.extend( jQuery.event, {
8564
8565	trigger: function( event, data, elem, onlyHandlers ) {
8566
8567		var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,
8568			eventPath = [ elem || document ],
8569			type = hasOwn.call( event, "type" ) ? event.type : event,
8570			namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
8571
8572		cur = lastElement = tmp = elem = elem || document;
8573
8574		// Don't do events on text and comment nodes
8575		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
8576			return;
8577		}
8578
8579		// focus/blur morphs to focusin/out; ensure we're not firing them right now
8580		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
8581			return;
8582		}
8583
8584		if ( type.indexOf( "." ) > -1 ) {
8585
8586			// Namespaced trigger; create a regexp to match event type in handle()
8587			namespaces = type.split( "." );
8588			type = namespaces.shift();
8589			namespaces.sort();
8590		}
8591		ontype = type.indexOf( ":" ) < 0 && "on" + type;
8592
8593		// Caller can pass in a jQuery.Event object, Object, or just an event type string
8594		event = event[ jQuery.expando ] ?
8595			event :
8596			new jQuery.Event( type, typeof event === "object" && event );
8597
8598		// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
8599		event.isTrigger = onlyHandlers ? 2 : 3;
8600		event.namespace = namespaces.join( "." );
8601		event.rnamespace = event.namespace ?
8602			new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
8603			null;
8604
8605		// Clean up the event in case it is being reused
8606		event.result = undefined;
8607		if ( !event.target ) {
8608			event.target = elem;
8609		}
8610
8611		// Clone any incoming data and prepend the event, creating the handler arg list
8612		data = data == null ?
8613			[ event ] :
8614			jQuery.makeArray( data, [ event ] );
8615
8616		// Allow special events to draw outside the lines
8617		special = jQuery.event.special[ type ] || {};
8618		if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
8619			return;
8620		}
8621
8622		// Determine event propagation path in advance, per W3C events spec (trac-9951)
8623		// Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724)
8624		if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {
8625
8626			bubbleType = special.delegateType || type;
8627			if ( !rfocusMorph.test( bubbleType + type ) ) {
8628				cur = cur.parentNode;
8629			}
8630			for ( ; cur; cur = cur.parentNode ) {
8631				eventPath.push( cur );
8632				tmp = cur;
8633			}
8634
8635			// Only add window if we got to document (e.g., not plain obj or detached DOM)
8636			if ( tmp === ( elem.ownerDocument || document ) ) {
8637				eventPath.push( tmp.defaultView || tmp.parentWindow || window );
8638			}
8639		}
8640
8641		// Fire handlers on the event path
8642		i = 0;
8643		while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
8644			lastElement = cur;
8645			event.type = i > 1 ?
8646				bubbleType :
8647				special.bindType || type;
8648
8649			// jQuery handler
8650			handle = ( dataPriv.get( cur, "events" ) || Object.create( null ) )[ event.type ] &&
8651				dataPriv.get( cur, "handle" );
8652			if ( handle ) {
8653				handle.apply( cur, data );
8654			}
8655
8656			// Native handler
8657			handle = ontype && cur[ ontype ];
8658			if ( handle && handle.apply && acceptData( cur ) ) {
8659				event.result = handle.apply( cur, data );
8660				if ( event.result === false ) {
8661					event.preventDefault();
8662				}
8663			}
8664		}
8665		event.type = type;
8666
8667		// If nobody prevented the default action, do it now
8668		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
8669
8670			if ( ( !special._default ||
8671				special._default.apply( eventPath.pop(), data ) === false ) &&
8672				acceptData( elem ) ) {
8673
8674				// Call a native DOM method on the target with the same name as the event.
8675				// Don't do default actions on window, that's where global variables be (trac-6170)
8676				if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {
8677
8678					// Don't re-trigger an onFOO event when we call its FOO() method
8679					tmp = elem[ ontype ];
8680
8681					if ( tmp ) {
8682						elem[ ontype ] = null;
8683					}
8684
8685					// Prevent re-triggering of the same event, since we already bubbled it above
8686					jQuery.event.triggered = type;
8687
8688					if ( event.isPropagationStopped() ) {
8689						lastElement.addEventListener( type, stopPropagationCallback );
8690					}
8691
8692					elem[ type ]();
8693
8694					if ( event.isPropagationStopped() ) {
8695						lastElement.removeEventListener( type, stopPropagationCallback );
8696					}
8697
8698					jQuery.event.triggered = undefined;
8699
8700					if ( tmp ) {
8701						elem[ ontype ] = tmp;
8702					}
8703				}
8704			}
8705		}
8706
8707		return event.result;
8708	},
8709
8710	// Piggyback on a donor event to simulate a different one
8711	// Used only for `focus(in | out)` events
8712	simulate: function( type, elem, event ) {
8713		var e = jQuery.extend(
8714			new jQuery.Event(),
8715			event,
8716			{
8717				type: type,
8718				isSimulated: true
8719			}
8720		);
8721
8722		jQuery.event.trigger( e, null, elem );
8723	}
8724
8725} );
8726
8727jQuery.fn.extend( {
8728
8729	trigger: function( type, data ) {
8730		return this.each( function() {
8731			jQuery.event.trigger( type, data, this );
8732		} );
8733	},
8734	triggerHandler: function( type, data ) {
8735		var elem = this[ 0 ];
8736		if ( elem ) {
8737			return jQuery.event.trigger( type, data, elem, true );
8738		}
8739	}
8740} );
8741
8742
8743var
8744	rbracket = /\[\]$/,
8745	rCRLF = /\r?\n/g,
8746	rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
8747	rsubmittable = /^(?:input|select|textarea|keygen)/i;
8748
8749function buildParams( prefix, obj, traditional, add ) {
8750	var name;
8751
8752	if ( Array.isArray( obj ) ) {
8753
8754		// Serialize array item.
8755		jQuery.each( obj, function( i, v ) {
8756			if ( traditional || rbracket.test( prefix ) ) {
8757
8758				// Treat each array item as a scalar.
8759				add( prefix, v );
8760
8761			} else {
8762
8763				// Item is non-scalar (array or object), encode its numeric index.
8764				buildParams(
8765					prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
8766					v,
8767					traditional,
8768					add
8769				);
8770			}
8771		} );
8772
8773	} else if ( !traditional && toType( obj ) === "object" ) {
8774
8775		// Serialize object item.
8776		for ( name in obj ) {
8777			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
8778		}
8779
8780	} else {
8781
8782		// Serialize scalar item.
8783		add( prefix, obj );
8784	}
8785}
8786
8787// Serialize an array of form elements or a set of
8788// key/values into a query string
8789jQuery.param = function( a, traditional ) {
8790	var prefix,
8791		s = [],
8792		add = function( key, valueOrFunction ) {
8793
8794			// If value is a function, invoke it and use its return value
8795			var value = isFunction( valueOrFunction ) ?
8796				valueOrFunction() :
8797				valueOrFunction;
8798
8799			s[ s.length ] = encodeURIComponent( key ) + "=" +
8800				encodeURIComponent( value == null ? "" : value );
8801		};
8802
8803	if ( a == null ) {
8804		return "";
8805	}
8806
8807	// If an array was passed in, assume that it is an array of form elements.
8808	if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
8809
8810		// Serialize the form elements
8811		jQuery.each( a, function() {
8812			add( this.name, this.value );
8813		} );
8814
8815	} else {
8816
8817		// If traditional, encode the "old" way (the way 1.3.2 or older
8818		// did it), otherwise encode params recursively.
8819		for ( prefix in a ) {
8820			buildParams( prefix, a[ prefix ], traditional, add );
8821		}
8822	}
8823
8824	// Return the resulting serialization
8825	return s.join( "&" );
8826};
8827
8828jQuery.fn.extend( {
8829	serialize: function() {
8830		return jQuery.param( this.serializeArray() );
8831	},
8832	serializeArray: function() {
8833		return this.map( function() {
8834
8835			// Can add propHook for "elements" to filter or add form elements
8836			var elements = jQuery.prop( this, "elements" );
8837			return elements ? jQuery.makeArray( elements ) : this;
8838		} ).filter( function() {
8839			var type = this.type;
8840
8841			// Use .is( ":disabled" ) so that fieldset[disabled] works
8842			return this.name && !jQuery( this ).is( ":disabled" ) &&
8843				rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
8844				( this.checked || !rcheckableType.test( type ) );
8845		} ).map( function( _i, elem ) {
8846			var val = jQuery( this ).val();
8847
8848			if ( val == null ) {
8849				return null;
8850			}
8851
8852			if ( Array.isArray( val ) ) {
8853				return jQuery.map( val, function( val ) {
8854					return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
8855				} );
8856			}
8857
8858			return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
8859		} ).get();
8860	}
8861} );
8862
8863
8864var
8865	r20 = /%20/g,
8866	rhash = /#.*$/,
8867	rantiCache = /([?&])_=[^&]*/,
8868	rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
8869
8870	// trac-7653, trac-8125, trac-8152: local protocol detection
8871	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
8872	rnoContent = /^(?:GET|HEAD)$/,
8873	rprotocol = /^\/\//,
8874
8875	/* Prefilters
8876	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
8877	 * 2) These are called:
8878	 *    - BEFORE asking for a transport
8879	 *    - AFTER param serialization (s.data is a string if s.processData is true)
8880	 * 3) key is the dataType
8881	 * 4) the catchall symbol "*" can be used
8882	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
8883	 */
8884	prefilters = {},
8885
8886	/* Transports bindings
8887	 * 1) key is the dataType
8888	 * 2) the catchall symbol "*" can be used
8889	 * 3) selection will start with transport dataType and THEN go to "*" if needed
8890	 */
8891	transports = {},
8892
8893	// Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression
8894	allTypes = "*/".concat( "*" ),
8895
8896	// Anchor tag for parsing the document origin
8897	originAnchor = document.createElement( "a" );
8898
8899originAnchor.href = location.href;
8900
8901// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
8902function addToPrefiltersOrTransports( structure ) {
8903
8904	// dataTypeExpression is optional and defaults to "*"
8905	return function( dataTypeExpression, func ) {
8906
8907		if ( typeof dataTypeExpression !== "string" ) {
8908			func = dataTypeExpression;
8909			dataTypeExpression = "*";
8910		}
8911
8912		var dataType,
8913			i = 0,
8914			dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
8915
8916		if ( isFunction( func ) ) {
8917
8918			// For each dataType in the dataTypeExpression
8919			while ( ( dataType = dataTypes[ i++ ] ) ) {
8920
8921				// Prepend if requested
8922				if ( dataType[ 0 ] === "+" ) {
8923					dataType = dataType.slice( 1 ) || "*";
8924					( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
8925
8926				// Otherwise append
8927				} else {
8928					( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
8929				}
8930			}
8931		}
8932	};
8933}
8934
8935// Base inspection function for prefilters and transports
8936function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
8937
8938	var inspected = {},
8939		seekingTransport = ( structure === transports );
8940
8941	function inspect( dataType ) {
8942		var selected;
8943		inspected[ dataType ] = true;
8944		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
8945			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
8946			if ( typeof dataTypeOrTransport === "string" &&
8947				!seekingTransport && !inspected[ dataTypeOrTransport ] ) {
8948
8949				options.dataTypes.unshift( dataTypeOrTransport );
8950				inspect( dataTypeOrTransport );
8951				return false;
8952			} else if ( seekingTransport ) {
8953				return !( selected = dataTypeOrTransport );
8954			}
8955		} );
8956		return selected;
8957	}
8958
8959	return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
8960}
8961
8962// A special extend for ajax options
8963// that takes "flat" options (not to be deep extended)
8964// Fixes trac-9887
8965function ajaxExtend( target, src ) {
8966	var key, deep,
8967		flatOptions = jQuery.ajaxSettings.flatOptions || {};
8968
8969	for ( key in src ) {
8970		if ( src[ key ] !== undefined ) {
8971			( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
8972		}
8973	}
8974	if ( deep ) {
8975		jQuery.extend( true, target, deep );
8976	}
8977
8978	return target;
8979}
8980
8981/* Handles responses to an ajax request:
8982 * - finds the right dataType (mediates between content-type and expected dataType)
8983 * - returns the corresponding response
8984 */
8985function ajaxHandleResponses( s, jqXHR, responses ) {
8986
8987	var ct, type, finalDataType, firstDataType,
8988		contents = s.contents,
8989		dataTypes = s.dataTypes;
8990
8991	// Remove auto dataType and get content-type in the process
8992	while ( dataTypes[ 0 ] === "*" ) {
8993		dataTypes.shift();
8994		if ( ct === undefined ) {
8995			ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
8996		}
8997	}
8998
8999	// Check if we're dealing with a known content-type
9000	if ( ct ) {
9001		for ( type in contents ) {
9002			if ( contents[ type ] && contents[ type ].test( ct ) ) {
9003				dataTypes.unshift( type );
9004				break;
9005			}
9006		}
9007	}
9008
9009	// Check to see if we have a response for the expected dataType
9010	if ( dataTypes[ 0 ] in responses ) {
9011		finalDataType = dataTypes[ 0 ];
9012	} else {
9013
9014		// Try convertible dataTypes
9015		for ( type in responses ) {
9016			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
9017				finalDataType = type;
9018				break;
9019			}
9020			if ( !firstDataType ) {
9021				firstDataType = type;
9022			}
9023		}
9024
9025		// Or just use first one
9026		finalDataType = finalDataType || firstDataType;
9027	}
9028
9029	// If we found a dataType
9030	// We add the dataType to the list if needed
9031	// and return the corresponding response
9032	if ( finalDataType ) {
9033		if ( finalDataType !== dataTypes[ 0 ] ) {
9034			dataTypes.unshift( finalDataType );
9035		}
9036		return responses[ finalDataType ];
9037	}
9038}
9039
9040/* Chain conversions given the request and the original response
9041 * Also sets the responseXXX fields on the jqXHR instance
9042 */
9043function ajaxConvert( s, response, jqXHR, isSuccess ) {
9044	var conv2, current, conv, tmp, prev,
9045		converters = {},
9046
9047		// Work with a copy of dataTypes in case we need to modify it for conversion
9048		dataTypes = s.dataTypes.slice();
9049
9050	// Create converters map with lowercased keys
9051	if ( dataTypes[ 1 ] ) {
9052		for ( conv in s.converters ) {
9053			converters[ conv.toLowerCase() ] = s.converters[ conv ];
9054		}
9055	}
9056
9057	current = dataTypes.shift();
9058
9059	// Convert to each sequential dataType
9060	while ( current ) {
9061
9062		if ( s.responseFields[ current ] ) {
9063			jqXHR[ s.responseFields[ current ] ] = response;
9064		}
9065
9066		// Apply the dataFilter if provided
9067		if ( !prev && isSuccess && s.dataFilter ) {
9068			response = s.dataFilter( response, s.dataType );
9069		}
9070
9071		prev = current;
9072		current = dataTypes.shift();
9073
9074		if ( current ) {
9075
9076			// There's only work to do if current dataType is non-auto
9077			if ( current === "*" ) {
9078
9079				current = prev;
9080
9081			// Convert response if prev dataType is non-auto and differs from current
9082			} else if ( prev !== "*" && prev !== current ) {
9083
9084				// Seek a direct converter
9085				conv = converters[ prev + " " + current ] || converters[ "* " + current ];
9086
9087				// If none found, seek a pair
9088				if ( !conv ) {
9089					for ( conv2 in converters ) {
9090
9091						// If conv2 outputs current
9092						tmp = conv2.split( " " );
9093						if ( tmp[ 1 ] === current ) {
9094
9095							// If prev can be converted to accepted input
9096							conv = converters[ prev + " " + tmp[ 0 ] ] ||
9097								converters[ "* " + tmp[ 0 ] ];
9098							if ( conv ) {
9099
9100								// Condense equivalence converters
9101								if ( conv === true ) {
9102									conv = converters[ conv2 ];
9103
9104								// Otherwise, insert the intermediate dataType
9105								} else if ( converters[ conv2 ] !== true ) {
9106									current = tmp[ 0 ];
9107									dataTypes.unshift( tmp[ 1 ] );
9108								}
9109								break;
9110							}
9111						}
9112					}
9113				}
9114
9115				// Apply converter (if not an equivalence)
9116				if ( conv !== true ) {
9117
9118					// Unless errors are allowed to bubble, catch and return them
9119					if ( conv && s.throws ) {
9120						response = conv( response );
9121					} else {
9122						try {
9123							response = conv( response );
9124						} catch ( e ) {
9125							return {
9126								state: "parsererror",
9127								error: conv ? e : "No conversion from " + prev + " to " + current
9128							};
9129						}
9130					}
9131				}
9132			}
9133		}
9134	}
9135
9136	return { state: "success", data: response };
9137}
9138
9139jQuery.extend( {
9140
9141	// Counter for holding the number of active queries
9142	active: 0,
9143
9144	// Last-Modified header cache for next request
9145	lastModified: {},
9146	etag: {},
9147
9148	ajaxSettings: {
9149		url: location.href,
9150		type: "GET",
9151		isLocal: rlocalProtocol.test( location.protocol ),
9152		global: true,
9153		processData: true,
9154		async: true,
9155		contentType: "application/x-www-form-urlencoded; charset=UTF-8",
9156
9157		/*
9158		timeout: 0,
9159		data: null,
9160		dataType: null,
9161		username: null,
9162		password: null,
9163		cache: null,
9164		throws: false,
9165		traditional: false,
9166		headers: {},
9167		*/
9168
9169		accepts: {
9170			"*": allTypes,
9171			text: "text/plain",
9172			html: "text/html",
9173			xml: "application/xml, text/xml",
9174			json: "application/json, text/javascript"
9175		},
9176
9177		contents: {
9178			xml: /\bxml\b/,
9179			html: /\bhtml/,
9180			json: /\bjson\b/
9181		},
9182
9183		responseFields: {
9184			xml: "responseXML",
9185			text: "responseText",
9186			json: "responseJSON"
9187		},
9188
9189		// Data converters
9190		// Keys separate source (or catchall "*") and destination types with a single space
9191		converters: {
9192
9193			// Convert anything to text
9194			"* text": String,
9195
9196			// Text to html (true = no transformation)
9197			"text html": true,
9198
9199			// Evaluate text as a json expression
9200			"text json": JSON.parse,
9201
9202			// Parse text as xml
9203			"text xml": jQuery.parseXML
9204		},
9205
9206		// For options that shouldn't be deep extended:
9207		// you can add your own custom options here if
9208		// and when you create one that shouldn't be
9209		// deep extended (see ajaxExtend)
9210		flatOptions: {
9211			url: true,
9212			context: true
9213		}
9214	},
9215
9216	// Creates a full fledged settings object into target
9217	// with both ajaxSettings and settings fields.
9218	// If target is omitted, writes into ajaxSettings.
9219	ajaxSetup: function( target, settings ) {
9220		return settings ?
9221
9222			// Building a settings object
9223			ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
9224
9225			// Extending ajaxSettings
9226			ajaxExtend( jQuery.ajaxSettings, target );
9227	},
9228
9229	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
9230	ajaxTransport: addToPrefiltersOrTransports( transports ),
9231
9232	// Main method
9233	ajax: function( url, options ) {
9234
9235		// If url is an object, simulate pre-1.5 signature
9236		if ( typeof url === "object" ) {
9237			options = url;
9238			url = undefined;
9239		}
9240
9241		// Force options to be an object
9242		options = options || {};
9243
9244		var transport,
9245
9246			// URL without anti-cache param
9247			cacheURL,
9248
9249			// Response headers
9250			responseHeadersString,
9251			responseHeaders,
9252
9253			// timeout handle
9254			timeoutTimer,
9255
9256			// Url cleanup var
9257			urlAnchor,
9258
9259			// Request state (becomes false upon send and true upon completion)
9260			completed,
9261
9262			// To know if global events are to be dispatched
9263			fireGlobals,
9264
9265			// Loop variable
9266			i,
9267
9268			// uncached part of the url
9269			uncached,
9270
9271			// Create the final options object
9272			s = jQuery.ajaxSetup( {}, options ),
9273
9274			// Callbacks context
9275			callbackContext = s.context || s,
9276
9277			// Context for global events is callbackContext if it is a DOM node or jQuery collection
9278			globalEventContext = s.context &&
9279				( callbackContext.nodeType || callbackContext.jquery ) ?
9280				jQuery( callbackContext ) :
9281				jQuery.event,
9282
9283			// Deferreds
9284			deferred = jQuery.Deferred(),
9285			completeDeferred = jQuery.Callbacks( "once memory" ),
9286
9287			// Status-dependent callbacks
9288			statusCode = s.statusCode || {},
9289
9290			// Headers (they are sent all at once)
9291			requestHeaders = {},
9292			requestHeadersNames = {},
9293
9294			// Default abort message
9295			strAbort = "canceled",
9296
9297			// Fake xhr
9298			jqXHR = {
9299				readyState: 0,
9300
9301				// Builds headers hashtable if needed
9302				getResponseHeader: function( key ) {
9303					var match;
9304					if ( completed ) {
9305						if ( !responseHeaders ) {
9306							responseHeaders = {};
9307							while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
9308								responseHeaders[ match[ 1 ].toLowerCase() + " " ] =
9309									( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] )
9310										.concat( match[ 2 ] );
9311							}
9312						}
9313						match = responseHeaders[ key.toLowerCase() + " " ];
9314					}
9315					return match == null ? null : match.join( ", " );
9316				},
9317
9318				// Raw string
9319				getAllResponseHeaders: function() {
9320					return completed ? responseHeadersString : null;
9321				},
9322
9323				// Caches the header
9324				setRequestHeader: function( name, value ) {
9325					if ( completed == null ) {
9326						name = requestHeadersNames[ name.toLowerCase() ] =
9327							requestHeadersNames[ name.toLowerCase() ] || name;
9328						requestHeaders[ name ] = value;
9329					}
9330					return this;
9331				},
9332
9333				// Overrides response content-type header
9334				overrideMimeType: function( type ) {
9335					if ( completed == null ) {
9336						s.mimeType = type;
9337					}
9338					return this;
9339				},
9340
9341				// Status-dependent callbacks
9342				statusCode: function( map ) {
9343					var code;
9344					if ( map ) {
9345						if ( completed ) {
9346
9347							// Execute the appropriate callbacks
9348							jqXHR.always( map[ jqXHR.status ] );
9349						} else {
9350
9351							// Lazy-add the new callbacks in a way that preserves old ones
9352							for ( code in map ) {
9353								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
9354							}
9355						}
9356					}
9357					return this;
9358				},
9359
9360				// Cancel the request
9361				abort: function( statusText ) {
9362					var finalText = statusText || strAbort;
9363					if ( transport ) {
9364						transport.abort( finalText );
9365					}
9366					done( 0, finalText );
9367					return this;
9368				}
9369			};
9370
9371		// Attach deferreds
9372		deferred.promise( jqXHR );
9373
9374		// Add protocol if not provided (prefilters might expect it)
9375		// Handle falsy url in the settings object (trac-10093: consistency with old signature)
9376		// We also use the url parameter if available
9377		s.url = ( ( url || s.url || location.href ) + "" )
9378			.replace( rprotocol, location.protocol + "//" );
9379
9380		// Alias method option to type as per ticket trac-12004
9381		s.type = options.method || options.type || s.method || s.type;
9382
9383		// Extract dataTypes list
9384		s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
9385
9386		// A cross-domain request is in order when the origin doesn't match the current origin.
9387		if ( s.crossDomain == null ) {
9388			urlAnchor = document.createElement( "a" );
9389
9390			// Support: IE <=8 - 11, Edge 12 - 15
9391			// IE throws exception on accessing the href property if url is malformed,
9392			// e.g. http://example.com:80x/
9393			try {
9394				urlAnchor.href = s.url;
9395
9396				// Support: IE <=8 - 11 only
9397				// Anchor's host property isn't correctly set when s.url is relative
9398				urlAnchor.href = urlAnchor.href;
9399				s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
9400					urlAnchor.protocol + "//" + urlAnchor.host;
9401			} catch ( e ) {
9402
9403				// If there is an error parsing the URL, assume it is crossDomain,
9404				// it can be rejected by the transport if it is invalid
9405				s.crossDomain = true;
9406			}
9407		}
9408
9409		// Convert data if not already a string
9410		if ( s.data && s.processData && typeof s.data !== "string" ) {
9411			s.data = jQuery.param( s.data, s.traditional );
9412		}
9413
9414		// Apply prefilters
9415		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
9416
9417		// If request was aborted inside a prefilter, stop there
9418		if ( completed ) {
9419			return jqXHR;
9420		}
9421
9422		// We can fire global events as of now if asked to
9423		// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (trac-15118)
9424		fireGlobals = jQuery.event && s.global;
9425
9426		// Watch for a new set of requests
9427		if ( fireGlobals && jQuery.active++ === 0 ) {
9428			jQuery.event.trigger( "ajaxStart" );
9429		}
9430
9431		// Uppercase the type
9432		s.type = s.type.toUpperCase();
9433
9434		// Determine if request has content
9435		s.hasContent = !rnoContent.test( s.type );
9436
9437		// Save the URL in case we're toying with the If-Modified-Since
9438		// and/or If-None-Match header later on
9439		// Remove hash to simplify url manipulation
9440		cacheURL = s.url.replace( rhash, "" );
9441
9442		// More options handling for requests with no content
9443		if ( !s.hasContent ) {
9444
9445			// Remember the hash so we can put it back
9446			uncached = s.url.slice( cacheURL.length );
9447
9448			// If data is available and should be processed, append data to url
9449			if ( s.data && ( s.processData || typeof s.data === "string" ) ) {
9450				cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
9451
9452				// trac-9682: remove data so that it's not used in an eventual retry
9453				delete s.data;
9454			}
9455
9456			// Add or update anti-cache param if needed
9457			if ( s.cache === false ) {
9458				cacheURL = cacheURL.replace( rantiCache, "$1" );
9459				uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) +
9460					uncached;
9461			}
9462
9463			// Put hash and anti-cache on the URL that will be requested (gh-1732)
9464			s.url = cacheURL + uncached;
9465
9466		// Change '%20' to '+' if this is encoded form body content (gh-2658)
9467		} else if ( s.data && s.processData &&
9468			( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
9469			s.data = s.data.replace( r20, "+" );
9470		}
9471
9472		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
9473		if ( s.ifModified ) {
9474			if ( jQuery.lastModified[ cacheURL ] ) {
9475				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
9476			}
9477			if ( jQuery.etag[ cacheURL ] ) {
9478				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
9479			}
9480		}
9481
9482		// Set the correct header, if data is being sent
9483		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
9484			jqXHR.setRequestHeader( "Content-Type", s.contentType );
9485		}
9486
9487		// Set the Accepts header for the server, depending on the dataType
9488		jqXHR.setRequestHeader(
9489			"Accept",
9490			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
9491				s.accepts[ s.dataTypes[ 0 ] ] +
9492					( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
9493				s.accepts[ "*" ]
9494		);
9495
9496		// Check for headers option
9497		for ( i in s.headers ) {
9498			jqXHR.setRequestHeader( i, s.headers[ i ] );
9499		}
9500
9501		// Allow custom headers/mimetypes and early abort
9502		if ( s.beforeSend &&
9503			( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
9504
9505			// Abort if not done already and return
9506			return jqXHR.abort();
9507		}
9508
9509		// Aborting is no longer a cancellation
9510		strAbort = "abort";
9511
9512		// Install callbacks on deferreds
9513		completeDeferred.add( s.complete );
9514		jqXHR.done( s.success );
9515		jqXHR.fail( s.error );
9516
9517		// Get transport
9518		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
9519
9520		// If no transport, we auto-abort
9521		if ( !transport ) {
9522			done( -1, "No Transport" );
9523		} else {
9524			jqXHR.readyState = 1;
9525
9526			// Send global event
9527			if ( fireGlobals ) {
9528				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
9529			}
9530
9531			// If request was aborted inside ajaxSend, stop there
9532			if ( completed ) {
9533				return jqXHR;
9534			}
9535
9536			// Timeout
9537			if ( s.async && s.timeout > 0 ) {
9538				timeoutTimer = window.setTimeout( function() {
9539					jqXHR.abort( "timeout" );
9540				}, s.timeout );
9541			}
9542
9543			try {
9544				completed = false;
9545				transport.send( requestHeaders, done );
9546			} catch ( e ) {
9547
9548				// Rethrow post-completion exceptions
9549				if ( completed ) {
9550					throw e;
9551				}
9552
9553				// Propagate others as results
9554				done( -1, e );
9555			}
9556		}
9557
9558		// Callback for when everything is done
9559		function done( status, nativeStatusText, responses, headers ) {
9560			var isSuccess, success, error, response, modified,
9561				statusText = nativeStatusText;
9562
9563			// Ignore repeat invocations
9564			if ( completed ) {
9565				return;
9566			}
9567
9568			completed = true;
9569
9570			// Clear timeout if it exists
9571			if ( timeoutTimer ) {
9572				window.clearTimeout( timeoutTimer );
9573			}
9574
9575			// Dereference transport for early garbage collection
9576			// (no matter how long the jqXHR object will be used)
9577			transport = undefined;
9578
9579			// Cache response headers
9580			responseHeadersString = headers || "";
9581
9582			// Set readyState
9583			jqXHR.readyState = status > 0 ? 4 : 0;
9584
9585			// Determine if successful
9586			isSuccess = status >= 200 && status < 300 || status === 304;
9587
9588			// Get response data
9589			if ( responses ) {
9590				response = ajaxHandleResponses( s, jqXHR, responses );
9591			}
9592
9593			// Use a noop converter for missing script but not if jsonp
9594			if ( !isSuccess &&
9595				jQuery.inArray( "script", s.dataTypes ) > -1 &&
9596				jQuery.inArray( "json", s.dataTypes ) < 0 ) {
9597				s.converters[ "text script" ] = function() {};
9598			}
9599
9600			// Convert no matter what (that way responseXXX fields are always set)
9601			response = ajaxConvert( s, response, jqXHR, isSuccess );
9602
9603			// If successful, handle type chaining
9604			if ( isSuccess ) {
9605
9606				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
9607				if ( s.ifModified ) {
9608					modified = jqXHR.getResponseHeader( "Last-Modified" );
9609					if ( modified ) {
9610						jQuery.lastModified[ cacheURL ] = modified;
9611					}
9612					modified = jqXHR.getResponseHeader( "etag" );
9613					if ( modified ) {
9614						jQuery.etag[ cacheURL ] = modified;
9615					}
9616				}
9617
9618				// if no content
9619				if ( status === 204 || s.type === "HEAD" ) {
9620					statusText = "nocontent";
9621
9622				// if not modified
9623				} else if ( status === 304 ) {
9624					statusText = "notmodified";
9625
9626				// If we have data, let's convert it
9627				} else {
9628					statusText = response.state;
9629					success = response.data;
9630					error = response.error;
9631					isSuccess = !error;
9632				}
9633			} else {
9634
9635				// Extract error from statusText and normalize for non-aborts
9636				error = statusText;
9637				if ( status || !statusText ) {
9638					statusText = "error";
9639					if ( status < 0 ) {
9640						status = 0;
9641					}
9642				}
9643			}
9644
9645			// Set data for the fake xhr object
9646			jqXHR.status = status;
9647			jqXHR.statusText = ( nativeStatusText || statusText ) + "";
9648
9649			// Success/Error
9650			if ( isSuccess ) {
9651				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
9652			} else {
9653				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
9654			}
9655
9656			// Status-dependent callbacks
9657			jqXHR.statusCode( statusCode );
9658			statusCode = undefined;
9659
9660			if ( fireGlobals ) {
9661				globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
9662					[ jqXHR, s, isSuccess ? success : error ] );
9663			}
9664
9665			// Complete
9666			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
9667
9668			if ( fireGlobals ) {
9669				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
9670
9671				// Handle the global AJAX counter
9672				if ( !( --jQuery.active ) ) {
9673					jQuery.event.trigger( "ajaxStop" );
9674				}
9675			}
9676		}
9677
9678		return jqXHR;
9679	},
9680
9681	getJSON: function( url, data, callback ) {
9682		return jQuery.get( url, data, callback, "json" );
9683	},
9684
9685	getScript: function( url, callback ) {
9686		return jQuery.get( url, undefined, callback, "script" );
9687	}
9688} );
9689
9690jQuery.each( [ "get", "post" ], function( _i, method ) {
9691	jQuery[ method ] = function( url, data, callback, type ) {
9692
9693		// Shift arguments if data argument was omitted
9694		if ( isFunction( data ) ) {
9695			type = type || callback;
9696			callback = data;
9697			data = undefined;
9698		}
9699
9700		// The url can be an options object (which then must have .url)
9701		return jQuery.ajax( jQuery.extend( {
9702			url: url,
9703			type: method,
9704			dataType: type,
9705			data: data,
9706			success: callback
9707		}, jQuery.isPlainObject( url ) && url ) );
9708	};
9709} );
9710
9711jQuery.ajaxPrefilter( function( s ) {
9712	var i;
9713	for ( i in s.headers ) {
9714		if ( i.toLowerCase() === "content-type" ) {
9715			s.contentType = s.headers[ i ] || "";
9716		}
9717	}
9718} );
9719
9720
9721jQuery._evalUrl = function( url, options, doc ) {
9722	return jQuery.ajax( {
9723		url: url,
9724
9725		// Make this explicit, since user can override this through ajaxSetup (trac-11264)
9726		type: "GET",
9727		dataType: "script",
9728		cache: true,
9729		async: false,
9730		global: false,
9731
9732		// Only evaluate the response if it is successful (gh-4126)
9733		// dataFilter is not invoked for failure responses, so using it instead
9734		// of the default converter is kludgy but it works.
9735		converters: {
9736			"text script": function() {}
9737		},
9738		dataFilter: function( response ) {
9739			jQuery.globalEval( response, options, doc );
9740		}
9741	} );
9742};
9743
9744
9745jQuery.fn.extend( {
9746	wrapAll: function( html ) {
9747		var wrap;
9748
9749		if ( this[ 0 ] ) {
9750			if ( isFunction( html ) ) {
9751				html = html.call( this[ 0 ] );
9752			}
9753
9754			// The elements to wrap the target around
9755			wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
9756
9757			if ( this[ 0 ].parentNode ) {
9758				wrap.insertBefore( this[ 0 ] );
9759			}
9760
9761			wrap.map( function() {
9762				var elem = this;
9763
9764				while ( elem.firstElementChild ) {
9765					elem = elem.firstElementChild;
9766				}
9767
9768				return elem;
9769			} ).append( this );
9770		}
9771
9772		return this;
9773	},
9774
9775	wrapInner: function( html ) {
9776		if ( isFunction( html ) ) {
9777			return this.each( function( i ) {
9778				jQuery( this ).wrapInner( html.call( this, i ) );
9779			} );
9780		}
9781
9782		return this.each( function() {
9783			var self = jQuery( this ),
9784				contents = self.contents();
9785
9786			if ( contents.length ) {
9787				contents.wrapAll( html );
9788
9789			} else {
9790				self.append( html );
9791			}
9792		} );
9793	},
9794
9795	wrap: function( html ) {
9796		var htmlIsFunction = isFunction( html );
9797
9798		return this.each( function( i ) {
9799			jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );
9800		} );
9801	},
9802
9803	unwrap: function( selector ) {
9804		this.parent( selector ).not( "body" ).each( function() {
9805			jQuery( this ).replaceWith( this.childNodes );
9806		} );
9807		return this;
9808	}
9809} );
9810
9811
9812jQuery.expr.pseudos.hidden = function( elem ) {
9813	return !jQuery.expr.pseudos.visible( elem );
9814};
9815jQuery.expr.pseudos.visible = function( elem ) {
9816	return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
9817};
9818
9819
9820
9821
9822jQuery.ajaxSettings.xhr = function() {
9823	try {
9824		return new window.XMLHttpRequest();
9825	} catch ( e ) {}
9826};
9827
9828var xhrSuccessStatus = {
9829
9830		// File protocol always yields status code 0, assume 200
9831		0: 200,
9832
9833		// Support: IE <=9 only
9834		// trac-1450: sometimes IE returns 1223 when it should be 204
9835		1223: 204
9836	},
9837	xhrSupported = jQuery.ajaxSettings.xhr();
9838
9839support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
9840support.ajax = xhrSupported = !!xhrSupported;
9841
9842jQuery.ajaxTransport( function( options ) {
9843	var callback, errorCallback;
9844
9845	// Cross domain only allowed if supported through XMLHttpRequest
9846	if ( support.cors || xhrSupported && !options.crossDomain ) {
9847		return {
9848			send: function( headers, complete ) {
9849				var i,
9850					xhr = options.xhr();
9851
9852				xhr.open(
9853					options.type,
9854					options.url,
9855					options.async,
9856					options.username,
9857					options.password
9858				);
9859
9860				// Apply custom fields if provided
9861				if ( options.xhrFields ) {
9862					for ( i in options.xhrFields ) {
9863						xhr[ i ] = options.xhrFields[ i ];
9864					}
9865				}
9866
9867				// Override mime type if needed
9868				if ( options.mimeType && xhr.overrideMimeType ) {
9869					xhr.overrideMimeType( options.mimeType );
9870				}
9871
9872				// X-Requested-With header
9873				// For cross-domain requests, seeing as conditions for a preflight are
9874				// akin to a jigsaw puzzle, we simply never set it to be sure.
9875				// (it can always be set on a per-request basis or even using ajaxSetup)
9876				// For same-domain requests, won't change header if already provided.
9877				if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
9878					headers[ "X-Requested-With" ] = "XMLHttpRequest";
9879				}
9880
9881				// Set headers
9882				for ( i in headers ) {
9883					xhr.setRequestHeader( i, headers[ i ] );
9884				}
9885
9886				// Callback
9887				callback = function( type ) {
9888					return function() {
9889						if ( callback ) {
9890							callback = errorCallback = xhr.onload =
9891								xhr.onerror = xhr.onabort = xhr.ontimeout =
9892									xhr.onreadystatechange = null;
9893
9894							if ( type === "abort" ) {
9895								xhr.abort();
9896							} else if ( type === "error" ) {
9897
9898								// Support: IE <=9 only
9899								// On a manual native abort, IE9 throws
9900								// errors on any property access that is not readyState
9901								if ( typeof xhr.status !== "number" ) {
9902									complete( 0, "error" );
9903								} else {
9904									complete(
9905
9906										// File: protocol always yields status 0; see trac-8605, trac-14207
9907										xhr.status,
9908										xhr.statusText
9909									);
9910								}
9911							} else {
9912								complete(
9913									xhrSuccessStatus[ xhr.status ] || xhr.status,
9914									xhr.statusText,
9915
9916									// Support: IE <=9 only
9917									// IE9 has no XHR2 but throws on binary (trac-11426)
9918									// For XHR2 non-text, let the caller handle it (gh-2498)
9919									( xhr.responseType || "text" ) !== "text"  ||
9920									typeof xhr.responseText !== "string" ?
9921										{ binary: xhr.response } :
9922										{ text: xhr.responseText },
9923									xhr.getAllResponseHeaders()
9924								);
9925							}
9926						}
9927					};
9928				};
9929
9930				// Listen to events
9931				xhr.onload = callback();
9932				errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" );
9933
9934				// Support: IE 9 only
9935				// Use onreadystatechange to replace onabort
9936				// to handle uncaught aborts
9937				if ( xhr.onabort !== undefined ) {
9938					xhr.onabort = errorCallback;
9939				} else {
9940					xhr.onreadystatechange = function() {
9941
9942						// Check readyState before timeout as it changes
9943						if ( xhr.readyState === 4 ) {
9944
9945							// Allow onerror to be called first,
9946							// but that will not handle a native abort
9947							// Also, save errorCallback to a variable
9948							// as xhr.onerror cannot be accessed
9949							window.setTimeout( function() {
9950								if ( callback ) {
9951									errorCallback();
9952								}
9953							} );
9954						}
9955					};
9956				}
9957
9958				// Create the abort callback
9959				callback = callback( "abort" );
9960
9961				try {
9962
9963					// Do send the request (this may raise an exception)
9964					xhr.send( options.hasContent && options.data || null );
9965				} catch ( e ) {
9966
9967					// trac-14683: Only rethrow if this hasn't been notified as an error yet
9968					if ( callback ) {
9969						throw e;
9970					}
9971				}
9972			},
9973
9974			abort: function() {
9975				if ( callback ) {
9976					callback();
9977				}
9978			}
9979		};
9980	}
9981} );
9982
9983
9984
9985
9986// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
9987jQuery.ajaxPrefilter( function( s ) {
9988	if ( s.crossDomain ) {
9989		s.contents.script = false;
9990	}
9991} );
9992
9993// Install script dataType
9994jQuery.ajaxSetup( {
9995	accepts: {
9996		script: "text/javascript, application/javascript, " +
9997			"application/ecmascript, application/x-ecmascript"
9998	},
9999	contents: {
10000		script: /\b(?:java|ecma)script\b/
10001	},
10002	converters: {
10003		"text script": function( text ) {
10004			jQuery.globalEval( text );
10005			return text;
10006		}
10007	}
10008} );
10009
10010// Handle cache's special case and crossDomain
10011jQuery.ajaxPrefilter( "script", function( s ) {
10012	if ( s.cache === undefined ) {
10013		s.cache = false;
10014	}
10015	if ( s.crossDomain ) {
10016		s.type = "GET";
10017	}
10018} );
10019
10020// Bind script tag hack transport
10021jQuery.ajaxTransport( "script", function( s ) {
10022
10023	// This transport only deals with cross domain or forced-by-attrs requests
10024	if ( s.crossDomain || s.scriptAttrs ) {
10025		var script, callback;
10026		return {
10027			send: function( _, complete ) {
10028				script = jQuery( "<script>" )
10029					.attr( s.scriptAttrs || {} )
10030					.prop( { charset: s.scriptCharset, src: s.url } )
10031					.on( "load error", callback = function( evt ) {
10032						script.remove();
10033						callback = null;
10034						if ( evt ) {
10035							complete( evt.type === "error" ? 404 : 200, evt.type );
10036						}
10037					} );
10038
10039				// Use native DOM manipulation to avoid our domManip AJAX trickery
10040				document.head.appendChild( script[ 0 ] );
10041			},
10042			abort: function() {
10043				if ( callback ) {
10044					callback();
10045				}
10046			}
10047		};
10048	}
10049} );
10050
10051
10052
10053
10054var oldCallbacks = [],
10055	rjsonp = /(=)\?(?=&|$)|\?\?/;
10056
10057// Default jsonp settings
10058jQuery.ajaxSetup( {
10059	jsonp: "callback",
10060	jsonpCallback: function() {
10061		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce.guid++ ) );
10062		this[ callback ] = true;
10063		return callback;
10064	}
10065} );
10066
10067// Detect, normalize options and install callbacks for jsonp requests
10068jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
10069
10070	var callbackName, overwritten, responseContainer,
10071		jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
10072			"url" :
10073			typeof s.data === "string" &&
10074				( s.contentType || "" )
10075					.indexOf( "application/x-www-form-urlencoded" ) === 0 &&
10076				rjsonp.test( s.data ) && "data"
10077		);
10078
10079	// Handle iff the expected data type is "jsonp" or we have a parameter to set
10080	if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
10081
10082		// Get callback name, remembering preexisting value associated with it
10083		callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?
10084			s.jsonpCallback() :
10085			s.jsonpCallback;
10086
10087		// Insert callback into url or form data
10088		if ( jsonProp ) {
10089			s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
10090		} else if ( s.jsonp !== false ) {
10091			s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
10092		}
10093
10094		// Use data converter to retrieve json after script execution
10095		s.converters[ "script json" ] = function() {
10096			if ( !responseContainer ) {
10097				jQuery.error( callbackName + " was not called" );
10098			}
10099			return responseContainer[ 0 ];
10100		};
10101
10102		// Force json dataType
10103		s.dataTypes[ 0 ] = "json";
10104
10105		// Install callback
10106		overwritten = window[ callbackName ];
10107		window[ callbackName ] = function() {
10108			responseContainer = arguments;
10109		};
10110
10111		// Clean-up function (fires after converters)
10112		jqXHR.always( function() {
10113
10114			// If previous value didn't exist - remove it
10115			if ( overwritten === undefined ) {
10116				jQuery( window ).removeProp( callbackName );
10117
10118			// Otherwise restore preexisting value
10119			} else {
10120				window[ callbackName ] = overwritten;
10121			}
10122
10123			// Save back as free
10124			if ( s[ callbackName ] ) {
10125
10126				// Make sure that re-using the options doesn't screw things around
10127				s.jsonpCallback = originalSettings.jsonpCallback;
10128
10129				// Save the callback name for future use
10130				oldCallbacks.push( callbackName );
10131			}
10132
10133			// Call if it was a function and we have a response
10134			if ( responseContainer && isFunction( overwritten ) ) {
10135				overwritten( responseContainer[ 0 ] );
10136			}
10137
10138			responseContainer = overwritten = undefined;
10139		} );
10140
10141		// Delegate to script
10142		return "script";
10143	}
10144} );
10145
10146
10147
10148
10149// Support: Safari 8 only
10150// In Safari 8 documents created via document.implementation.createHTMLDocument
10151// collapse sibling forms: the second one becomes a child of the first one.
10152// Because of that, this security measure has to be disabled in Safari 8.
10153// https://bugs.webkit.org/show_bug.cgi?id=137337
10154support.createHTMLDocument = ( function() {
10155	var body = document.implementation.createHTMLDocument( "" ).body;
10156	body.innerHTML = "<form></form><form></form>";
10157	return body.childNodes.length === 2;
10158} )();
10159
10160
10161// Argument "data" should be string of html
10162// context (optional): If specified, the fragment will be created in this context,
10163// defaults to document
10164// keepScripts (optional): If true, will include scripts passed in the html string
10165jQuery.parseHTML = function( data, context, keepScripts ) {
10166	if ( typeof data !== "string" ) {
10167		return [];
10168	}
10169	if ( typeof context === "boolean" ) {
10170		keepScripts = context;
10171		context = false;
10172	}
10173
10174	var base, parsed, scripts;
10175
10176	if ( !context ) {
10177
10178		// Stop scripts or inline event handlers from being executed immediately
10179		// by using document.implementation
10180		if ( support.createHTMLDocument ) {
10181			context = document.implementation.createHTMLDocument( "" );
10182
10183			// Set the base href for the created document
10184			// so any parsed elements with URLs
10185			// are based on the document's URL (gh-2965)
10186			base = context.createElement( "base" );
10187			base.href = document.location.href;
10188			context.head.appendChild( base );
10189		} else {
10190			context = document;
10191		}
10192	}
10193
10194	parsed = rsingleTag.exec( data );
10195	scripts = !keepScripts && [];
10196
10197	// Single tag
10198	if ( parsed ) {
10199		return [ context.createElement( parsed[ 1 ] ) ];
10200	}
10201
10202	parsed = buildFragment( [ data ], context, scripts );
10203
10204	if ( scripts && scripts.length ) {
10205		jQuery( scripts ).remove();
10206	}
10207
10208	return jQuery.merge( [], parsed.childNodes );
10209};
10210
10211
10212/**
10213 * Load a url into a page
10214 */
10215jQuery.fn.load = function( url, params, callback ) {
10216	var selector, type, response,
10217		self = this,
10218		off = url.indexOf( " " );
10219
10220	if ( off > -1 ) {
10221		selector = stripAndCollapse( url.slice( off ) );
10222		url = url.slice( 0, off );
10223	}
10224
10225	// If it's a function
10226	if ( isFunction( params ) ) {
10227
10228		// We assume that it's the callback
10229		callback = params;
10230		params = undefined;
10231
10232	// Otherwise, build a param string
10233	} else if ( params && typeof params === "object" ) {
10234		type = "POST";
10235	}
10236
10237	// If we have elements to modify, make the request
10238	if ( self.length > 0 ) {
10239		jQuery.ajax( {
10240			url: url,
10241
10242			// If "type" variable is undefined, then "GET" method will be used.
10243			// Make value of this field explicit since
10244			// user can override it through ajaxSetup method
10245			type: type || "GET",
10246			dataType: "html",
10247			data: params
10248		} ).done( function( responseText ) {
10249
10250			// Save response for use in complete callback
10251			response = arguments;
10252
10253			self.html( selector ?
10254
10255				// If a selector was specified, locate the right elements in a dummy div
10256				// Exclude scripts to avoid IE 'Permission Denied' errors
10257				jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
10258
10259				// Otherwise use the full result
10260				responseText );
10261
10262		// If the request succeeds, this function gets "data", "status", "jqXHR"
10263		// but they are ignored because response was set above.
10264		// If it fails, this function gets "jqXHR", "status", "error"
10265		} ).always( callback && function( jqXHR, status ) {
10266			self.each( function() {
10267				callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
10268			} );
10269		} );
10270	}
10271
10272	return this;
10273};
10274
10275
10276
10277
10278jQuery.expr.pseudos.animated = function( elem ) {
10279	return jQuery.grep( jQuery.timers, function( fn ) {
10280		return elem === fn.elem;
10281	} ).length;
10282};
10283
10284
10285
10286
10287jQuery.offset = {
10288	setOffset: function( elem, options, i ) {
10289		var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
10290			position = jQuery.css( elem, "position" ),
10291			curElem = jQuery( elem ),
10292			props = {};
10293
10294		// Set position first, in-case top/left are set even on static elem
10295		if ( position === "static" ) {
10296			elem.style.position = "relative";
10297		}
10298
10299		curOffset = curElem.offset();
10300		curCSSTop = jQuery.css( elem, "top" );
10301		curCSSLeft = jQuery.css( elem, "left" );
10302		calculatePosition = ( position === "absolute" || position === "fixed" ) &&
10303			( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;
10304
10305		// Need to be able to calculate position if either
10306		// top or left is auto and position is either absolute or fixed
10307		if ( calculatePosition ) {
10308			curPosition = curElem.position();
10309			curTop = curPosition.top;
10310			curLeft = curPosition.left;
10311
10312		} else {
10313			curTop = parseFloat( curCSSTop ) || 0;
10314			curLeft = parseFloat( curCSSLeft ) || 0;
10315		}
10316
10317		if ( isFunction( options ) ) {
10318
10319			// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
10320			options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
10321		}
10322
10323		if ( options.top != null ) {
10324			props.top = ( options.top - curOffset.top ) + curTop;
10325		}
10326		if ( options.left != null ) {
10327			props.left = ( options.left - curOffset.left ) + curLeft;
10328		}
10329
10330		if ( "using" in options ) {
10331			options.using.call( elem, props );
10332
10333		} else {
10334			curElem.css( props );
10335		}
10336	}
10337};
10338
10339jQuery.fn.extend( {
10340
10341	// offset() relates an element's border box to the document origin
10342	offset: function( options ) {
10343
10344		// Preserve chaining for setter
10345		if ( arguments.length ) {
10346			return options === undefined ?
10347				this :
10348				this.each( function( i ) {
10349					jQuery.offset.setOffset( this, options, i );
10350				} );
10351		}
10352
10353		var rect, win,
10354			elem = this[ 0 ];
10355
10356		if ( !elem ) {
10357			return;
10358		}
10359
10360		// Return zeros for disconnected and hidden (display: none) elements (gh-2310)
10361		// Support: IE <=11 only
10362		// Running getBoundingClientRect on a
10363		// disconnected node in IE throws an error
10364		if ( !elem.getClientRects().length ) {
10365			return { top: 0, left: 0 };
10366		}
10367
10368		// Get document-relative position by adding viewport scroll to viewport-relative gBCR
10369		rect = elem.getBoundingClientRect();
10370		win = elem.ownerDocument.defaultView;
10371		return {
10372			top: rect.top + win.pageYOffset,
10373			left: rect.left + win.pageXOffset
10374		};
10375	},
10376
10377	// position() relates an element's margin box to its offset parent's padding box
10378	// This corresponds to the behavior of CSS absolute positioning
10379	position: function() {
10380		if ( !this[ 0 ] ) {
10381			return;
10382		}
10383
10384		var offsetParent, offset, doc,
10385			elem = this[ 0 ],
10386			parentOffset = { top: 0, left: 0 };
10387
10388		// position:fixed elements are offset from the viewport, which itself always has zero offset
10389		if ( jQuery.css( elem, "position" ) === "fixed" ) {
10390
10391			// Assume position:fixed implies availability of getBoundingClientRect
10392			offset = elem.getBoundingClientRect();
10393
10394		} else {
10395			offset = this.offset();
10396
10397			// Account for the *real* offset parent, which can be the document or its root element
10398			// when a statically positioned element is identified
10399			doc = elem.ownerDocument;
10400			offsetParent = elem.offsetParent || doc.documentElement;
10401			while ( offsetParent &&
10402				( offsetParent === doc.body || offsetParent === doc.documentElement ) &&
10403				jQuery.css( offsetParent, "position" ) === "static" ) {
10404
10405				offsetParent = offsetParent.parentNode;
10406			}
10407			if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {
10408
10409				// Incorporate borders into its offset, since they are outside its content origin
10410				parentOffset = jQuery( offsetParent ).offset();
10411				parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true );
10412				parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true );
10413			}
10414		}
10415
10416		// Subtract parent offsets and element margins
10417		return {
10418			top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
10419			left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
10420		};
10421	},
10422
10423	// This method will return documentElement in the following cases:
10424	// 1) For the element inside the iframe without offsetParent, this method will return
10425	//    documentElement of the parent window
10426	// 2) For the hidden or detached element
10427	// 3) For body or html element, i.e. in case of the html node - it will return itself
10428	//
10429	// but those exceptions were never presented as a real life use-cases
10430	// and might be considered as more preferable results.
10431	//
10432	// This logic, however, is not guaranteed and can change at any point in the future
10433	offsetParent: function() {
10434		return this.map( function() {
10435			var offsetParent = this.offsetParent;
10436
10437			while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
10438				offsetParent = offsetParent.offsetParent;
10439			}
10440
10441			return offsetParent || documentElement;
10442		} );
10443	}
10444} );
10445
10446// Create scrollLeft and scrollTop methods
10447jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
10448	var top = "pageYOffset" === prop;
10449
10450	jQuery.fn[ method ] = function( val ) {
10451		return access( this, function( elem, method, val ) {
10452
10453			// Coalesce documents and windows
10454			var win;
10455			if ( isWindow( elem ) ) {
10456				win = elem;
10457			} else if ( elem.nodeType === 9 ) {
10458				win = elem.defaultView;
10459			}
10460
10461			if ( val === undefined ) {
10462				return win ? win[ prop ] : elem[ method ];
10463			}
10464
10465			if ( win ) {
10466				win.scrollTo(
10467					!top ? val : win.pageXOffset,
10468					top ? val : win.pageYOffset
10469				);
10470
10471			} else {
10472				elem[ method ] = val;
10473			}
10474		}, method, val, arguments.length );
10475	};
10476} );
10477
10478// Support: Safari <=7 - 9.1, Chrome <=37 - 49
10479// Add the top/left cssHooks using jQuery.fn.position
10480// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
10481// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
10482// getComputedStyle returns percent when specified for top/left/bottom/right;
10483// rather than make the css module depend on the offset module, just check for it here
10484jQuery.each( [ "top", "left" ], function( _i, prop ) {
10485	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
10486		function( elem, computed ) {
10487			if ( computed ) {
10488				computed = curCSS( elem, prop );
10489
10490				// If curCSS returns percentage, fallback to offset
10491				return rnumnonpx.test( computed ) ?
10492					jQuery( elem ).position()[ prop ] + "px" :
10493					computed;
10494			}
10495		}
10496	);
10497} );
10498
10499
10500// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
10501jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
10502	jQuery.each( {
10503		padding: "inner" + name,
10504		content: type,
10505		"": "outer" + name
10506	}, function( defaultExtra, funcName ) {
10507
10508		// Margin is only for outerHeight, outerWidth
10509		jQuery.fn[ funcName ] = function( margin, value ) {
10510			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
10511				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
10512
10513			return access( this, function( elem, type, value ) {
10514				var doc;
10515
10516				if ( isWindow( elem ) ) {
10517
10518					// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
10519					return funcName.indexOf( "outer" ) === 0 ?
10520						elem[ "inner" + name ] :
10521						elem.document.documentElement[ "client" + name ];
10522				}
10523
10524				// Get document width or height
10525				if ( elem.nodeType === 9 ) {
10526					doc = elem.documentElement;
10527
10528					// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
10529					// whichever is greatest
10530					return Math.max(
10531						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
10532						elem.body[ "offset" + name ], doc[ "offset" + name ],
10533						doc[ "client" + name ]
10534					);
10535				}
10536
10537				return value === undefined ?
10538
10539					// Get width or height on the element, requesting but not forcing parseFloat
10540					jQuery.css( elem, type, extra ) :
10541
10542					// Set width or height on the element
10543					jQuery.style( elem, type, value, extra );
10544			}, type, chainable ? margin : undefined, chainable );
10545		};
10546	} );
10547} );
10548
10549
10550jQuery.each( [
10551	"ajaxStart",
10552	"ajaxStop",
10553	"ajaxComplete",
10554	"ajaxError",
10555	"ajaxSuccess",
10556	"ajaxSend"
10557], function( _i, type ) {
10558	jQuery.fn[ type ] = function( fn ) {
10559		return this.on( type, fn );
10560	};
10561} );
10562
10563
10564
10565
10566jQuery.fn.extend( {
10567
10568	bind: function( types, data, fn ) {
10569		return this.on( types, null, data, fn );
10570	},
10571	unbind: function( types, fn ) {
10572		return this.off( types, null, fn );
10573	},
10574
10575	delegate: function( selector, types, data, fn ) {
10576		return this.on( types, selector, data, fn );
10577	},
10578	undelegate: function( selector, types, fn ) {
10579
10580		// ( namespace ) or ( selector, types [, fn] )
10581		return arguments.length === 1 ?
10582			this.off( selector, "**" ) :
10583			this.off( types, selector || "**", fn );
10584	},
10585
10586	hover: function( fnOver, fnOut ) {
10587		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
10588	}
10589} );
10590
10591jQuery.each(
10592	( "blur focus focusin focusout resize scroll click dblclick " +
10593	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
10594	"change select submit keydown keypress keyup contextmenu" ).split( " " ),
10595	function( _i, name ) {
10596
10597		// Handle event binding
10598		jQuery.fn[ name ] = function( data, fn ) {
10599			return arguments.length > 0 ?
10600				this.on( name, null, data, fn ) :
10601				this.trigger( name );
10602		};
10603	}
10604);
10605
10606
10607
10608
10609// Support: Android <=4.0 only
10610// Make sure we trim BOM and NBSP
10611// Require that the "whitespace run" starts from a non-whitespace
10612// to avoid O(N^2) behavior when the engine would try matching "\s+$" at each space position.
10613var rtrim = /^[\s\uFEFF\xA0]+|([^\s\uFEFF\xA0])[\s\uFEFF\xA0]+$/g;
10614
10615// Bind a function to a context, optionally partially applying any
10616// arguments.
10617// jQuery.proxy is deprecated to promote standards (specifically Function#bind)
10618// However, it is not slated for removal any time soon
10619jQuery.proxy = function( fn, context ) {
10620	var tmp, args, proxy;
10621
10622	if ( typeof context === "string" ) {
10623		tmp = fn[ context ];
10624		context = fn;
10625		fn = tmp;
10626	}
10627
10628	// Quick check to determine if target is callable, in the spec
10629	// this throws a TypeError, but we will just return undefined.
10630	if ( !isFunction( fn ) ) {
10631		return undefined;
10632	}
10633
10634	// Simulated bind
10635	args = slice.call( arguments, 2 );
10636	proxy = function() {
10637		return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
10638	};
10639
10640	// Set the guid of unique handler to the same of original handler, so it can be removed
10641	proxy.guid = fn.guid = fn.guid || jQuery.guid++;
10642
10643	return proxy;
10644};
10645
10646jQuery.holdReady = function( hold ) {
10647	if ( hold ) {
10648		jQuery.readyWait++;
10649	} else {
10650		jQuery.ready( true );
10651	}
10652};
10653jQuery.isArray = Array.isArray;
10654jQuery.parseJSON = JSON.parse;
10655jQuery.nodeName = nodeName;
10656jQuery.isFunction = isFunction;
10657jQuery.isWindow = isWindow;
10658jQuery.camelCase = camelCase;
10659jQuery.type = toType;
10660
10661jQuery.now = Date.now;
10662
10663jQuery.isNumeric = function( obj ) {
10664
10665	// As of jQuery 3.0, isNumeric is limited to
10666	// strings and numbers (primitives or objects)
10667	// that can be coerced to finite numbers (gh-2662)
10668	var type = jQuery.type( obj );
10669	return ( type === "number" || type === "string" ) &&
10670
10671		// parseFloat NaNs numeric-cast false positives ("")
10672		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
10673		// subtraction forces infinities to NaN
10674		!isNaN( obj - parseFloat( obj ) );
10675};
10676
10677jQuery.trim = function( text ) {
10678	return text == null ?
10679		"" :
10680		( text + "" ).replace( rtrim, "$1" );
10681};
10682
10683
10684
10685// Register as a named AMD module, since jQuery can be concatenated with other
10686// files that may use define, but not via a proper concatenation script that
10687// understands anonymous AMD modules. A named AMD is safest and most robust
10688// way to register. Lowercase jquery is used because AMD module names are
10689// derived from file names, and jQuery is normally delivered in a lowercase
10690// file name. Do this after creating the global so that if an AMD module wants
10691// to call noConflict to hide this version of jQuery, it will work.
10692
10693// Note that for maximum portability, libraries that are not jQuery should
10694// declare themselves as anonymous modules, and avoid setting a global if an
10695// AMD loader is present. jQuery is a special case. For more information, see
10696// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
10697
10698if ( true ) {
10699	!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function() {
10700		return jQuery;
10701	}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
10702		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
10703}
10704
10705
10706
10707
10708var
10709
10710	// Map over jQuery in case of overwrite
10711	_jQuery = window.jQuery,
10712
10713	// Map over the $ in case of overwrite
10714	_$ = window.$;
10715
10716jQuery.noConflict = function( deep ) {
10717	if ( window.$ === jQuery ) {
10718		window.$ = _$;
10719	}
10720
10721	if ( deep && window.jQuery === jQuery ) {
10722		window.jQuery = _jQuery;
10723	}
10724
10725	return jQuery;
10726};
10727
10728// Expose jQuery and $ identifiers, even in AMD
10729// (trac-7102#comment:10, https://github.com/jquery/jquery/pull/557)
10730// and CommonJS for browser emulators (trac-13566)
10731if ( typeof noGlobal === "undefined" ) {
10732	window.jQuery = window.$ = jQuery;
10733}
10734
10735
10736
10737
10738return jQuery;
10739} );
10740
10741
10742/***/ }),
10743