UNPKG

jquery/dist/jquery.js

Version:
294 kBJavaScriptView Raw
1/*!
* jQuery JavaScript Library v3.6.3
* https://jquery.com/
*
* Includes Sizzle.js
* https://sizzlejs.com/
*
* Copyright OpenJS Foundation and other contributors
* Released under the MIT license
* https://jquery.org/license
*
* Date: 2022-12-20T21:28Z
*/
14( function( global, factory ) {
15
"use strict";
17
if ( typeof module === "object" && typeof module.exports === "object" ) {
19
// For CommonJS and CommonJS-like environments where a proper `window`
// is present, execute the factory and get jQuery.
// For environments that do not have a `window` with a `document`
// (such as Node.js), expose a factory as module.exports.
// This accentuates the need for the creation of a real `window`.
// e.g. var jQuery = require("jquery")(window);
// See ticket trac-14549 for more info.
module.exports = global.document ?
	factory( global, true ) :
	function( w ) {
		if ( !w.document ) {
			throw new Error( "jQuery requires a window with a document" );
		}
		return factory( w );
	};
} else {
factory( global );
}
38
39// Pass this if window is not defined yet
40} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
41
42// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
43// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
44// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
45// enough that all such attempts are guarded in a try block.
46"use strict";
47
48var arr = [];
49
50var getProto = Object.getPrototypeOf;
51
52var slice = arr.slice;
53
54var flat = arr.flat ? function( array ) {
return arr.flat.call( array );
56} : function( array ) {
return arr.concat.apply( [], array );
58};
59
60
61var push = arr.push;
62
63var indexOf = arr.indexOf;
64
65var class2type = {};
66
67var toString = class2type.toString;
68
69var hasOwn = class2type.hasOwnProperty;
70
71var fnToString = hasOwn.toString;
72
73var ObjectFunctionString = fnToString.call( Object );
74
75var support = {};
76
77var isFunction = function isFunction( obj ) {
78
// Support: Chrome <=57, Firefox <=52
// In some browsers, typeof returns "function" for HTML <object> elements
// (i.e., `typeof document.createElement( "object" ) === "function"`).
// We don't want to classify *any* DOM node as a function.
// Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5
// Plus for old WebKit, typeof returns "function" for HTML collections
// (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756)
return typeof obj === "function" && typeof obj.nodeType !== "number" &&
	typeof obj.item !== "function";
};
89
90
91var isWindow = function isWindow( obj ) {
return obj != null && obj === obj.window;
};
94
95
96var document = window.document;
97
98
99
var preservedScriptAttributes = {
type: true,
src: true,
nonce: true,
noModule: true
};
106
function DOMEval( code, node, doc ) {
doc = doc || document;
109
var i, val,
	script = doc.createElement( "script" );
112
script.text = code;
if ( node ) {
	for ( i in preservedScriptAttributes ) {
116
		// Support: Firefox 64+, Edge 18+
		// Some browsers don't support the "nonce" property on scripts.
		// On the other hand, just using `getAttribute` is not enough as
		// the `nonce` attribute is reset to an empty string whenever it
		// becomes browsing-context connected.
		// See https://github.com/whatwg/html/issues/2369
		// See https://html.spec.whatwg.org/#nonce-attributes
		// The `node.getAttribute` check was added for the sake of
		// `jQuery.globalEval` so that it can fake a nonce-containing node
		// via an object.
		val = node[ i ] || node.getAttribute && node.getAttribute( i );
		if ( val ) {
			script.setAttribute( i, val );
		}
	}
}
doc.head.appendChild( script ).parentNode.removeChild( script );
}
135
136
137function toType( obj ) {
if ( obj == null ) {
return obj + "";
}
141
// Support: Android <=2.3 only (functionish RegExp)
return typeof obj === "object" || typeof obj === "function" ?
class2type[ toString.call( obj ) ] || "object" :
typeof obj;
146}
147/* global Symbol */
148// Defining this global in .eslintrc.json would create a danger of using the global
149// unguarded in another place, it seems safer to define global only for this module
150
151
152
153var
version = "3.6.3",
155
// Define a local copy of jQuery
jQuery = function( selector, context ) {
158
// The jQuery object is actually just the init constructor 'enhanced'
// Need init if jQuery is called (just allow error to be thrown if not included)
return new jQuery.fn.init( selector, context );
};
163
164jQuery.fn = jQuery.prototype = {
165
// The current version of jQuery being used
jquery: version,
168
constructor: jQuery,
170
// The default length of a jQuery object is 0
length: 0,
173
toArray: function() {
return slice.call( this );
},
177
// Get the Nth element in the matched element set OR
// Get the whole matched element set as a clean array
get: function( num ) {
181
// Return all the elements in a clean array
if ( num == null ) {
	return slice.call( this );
}
186
// Return just the one element from the set
return num < 0 ? this[ num + this.length ] : this[ num ];
},
190
// Take an array of elements and push it onto the stack
// (returning the new matched element set)
pushStack: function( elems ) {
194
// Build a new jQuery matched element set
var ret = jQuery.merge( this.constructor(), elems );
197
// Add the old object onto the stack (as a reference)
ret.prevObject = this;
200
// Return the newly-formed element set
return ret;
},
204
// Execute a callback for every element in the matched set.
each: function( callback ) {
return jQuery.each( this, callback );
},
209
map: function( callback ) {
return this.pushStack( jQuery.map( this, function( elem, i ) {
	return callback.call( elem, i, elem );
} ) );
},
215
slice: function() {
return this.pushStack( slice.apply( this, arguments ) );
},
219
first: function() {
return this.eq( 0 );
},
223
last: function() {
return this.eq( -1 );
},
227
even: function() {
return this.pushStack( jQuery.grep( this, function( _elem, i ) {
	return ( i + 1 ) % 2;
} ) );
},
233
odd: function() {
return this.pushStack( jQuery.grep( this, function( _elem, i ) {
	return i % 2;
} ) );
},
239
eq: function( i ) {
var len = this.length,
	j = +i + ( i < 0 ? len : 0 );
return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
},
245
end: function() {
return this.prevObject || this.constructor();
},
249
// For internal use only.
// Behaves like an Array's method, not like a jQuery method.
push: push,
sort: arr.sort,
splice: arr.splice
255};
256
257jQuery.extend = jQuery.fn.extend = function() {
var options, name, src, copy, copyIsArray, clone,
target = arguments[ 0 ] || {},
i = 1,
length = arguments.length,
deep = false;
263
// Handle a deep copy situation
if ( typeof target === "boolean" ) {
deep = target;
267
// Skip the boolean and the target
target = arguments[ i ] || {};
i++;
}
272
// Handle case when target is a string or something (possible in deep copy)
if ( typeof target !== "object" && !isFunction( target ) ) {
target = {};
}
277
// Extend jQuery itself if only one argument is passed
if ( i === length ) {
target = this;
i--;
}
283
for ( ; i < length; i++ ) {
285
// Only deal with non-null/undefined values
if ( ( options = arguments[ i ] ) != null ) {
288
	// Extend the base object
	for ( name in options ) {
		copy = options[ name ];
292
		// Prevent Object.prototype pollution
		// Prevent never-ending loop
		if ( name === "__proto__" || target === copy ) {
			continue;
		}
298
		// Recurse if we're merging plain objects or arrays
		if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
			( copyIsArray = Array.isArray( copy ) ) ) ) {
			src = target[ name ];
303
			// Ensure proper type for the source value
			if ( copyIsArray && !Array.isArray( src ) ) {
				clone = [];
			} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
				clone = {};
			} else {
				clone = src;
			}
			copyIsArray = false;
313
			// Never move original objects, clone them
			target[ name ] = jQuery.extend( deep, clone, copy );
316
		// Don't bring in undefined values
		} else if ( copy !== undefined ) {
			target[ name ] = copy;
		}
	}
}
}
324
// Return the modified object
return target;
327};
328
329jQuery.extend( {
330
// Unique for each copy of jQuery on the page
expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
333
// Assume jQuery is ready without the ready module
isReady: true,
336
error: function( msg ) {
throw new Error( msg );
},
340
noop: function() {},
342
isPlainObject: function( obj ) {
var proto, Ctor;
345
// Detect obvious negatives
// Use toString instead of jQuery.type to catch host objects
if ( !obj || toString.call( obj ) !== "[object Object]" ) {
	return false;
}
351
proto = getProto( obj );
353
// Objects with no prototype (e.g., `Object.create( null )`) are plain
if ( !proto ) {
	return true;
}
358
// Objects with prototype are plain iff they were constructed by a global Object function
Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
},
363
isEmptyObject: function( obj ) {
var name;
366
for ( name in obj ) {
	return false;
}
return true;
},
372
// Evaluates a script in a provided context; falls back to the global one
// if not specified.
globalEval: function( code, options, doc ) {
DOMEval( code, { nonce: options && options.nonce }, doc );
},
378
each: function( obj, callback ) {
var length, i = 0;
381
if ( isArrayLike( obj ) ) {
	length = obj.length;
	for ( ; i < length; i++ ) {
		if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
			break;
		}
	}
} else {
	for ( i in obj ) {
		if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
			break;
		}
	}
}
396
return obj;
},
399
// results is for internal usage only
makeArray: function( arr, results ) {
var ret = results || [];
403
if ( arr != null ) {
	if ( isArrayLike( Object( arr ) ) ) {
		jQuery.merge( ret,
			typeof arr === "string" ?
				[ arr ] : arr
		);
	} else {
		push.call( ret, arr );
	}
}
414
return ret;
},
417
inArray: function( elem, arr, i ) {
return arr == null ? -1 : indexOf.call( arr, elem, i );
},
421
// Support: Android <=4.0 only, PhantomJS 1 only
// push.apply(_, arraylike) throws on ancient WebKit
merge: function( first, second ) {
var len = +second.length,
	j = 0,
	i = first.length;
428
for ( ; j < len; j++ ) {
	first[ i++ ] = second[ j ];
}
432
first.length = i;
434
return first;
},
437
grep: function( elems, callback, invert ) {
var callbackInverse,
	matches = [],
	i = 0,
	length = elems.length,
	callbackExpect = !invert;
444
// Go through the array, only saving the items
// that pass the validator function
for ( ; i < length; i++ ) {
	callbackInverse = !callback( elems[ i ], i );
	if ( callbackInverse !== callbackExpect ) {
		matches.push( elems[ i ] );
	}
}
453
return matches;
},
456
// arg is for internal usage only
map: function( elems, callback, arg ) {
var length, value,
	i = 0,
	ret = [];
462
// Go through the array, translating each of the items to their new values
if ( isArrayLike( elems ) ) {
	length = elems.length;
	for ( ; i < length; i++ ) {
		value = callback( elems[ i ], i, arg );
468
		if ( value != null ) {
			ret.push( value );
		}
	}
473
// Go through every key on the object,
} else {
	for ( i in elems ) {
		value = callback( elems[ i ], i, arg );
478
		if ( value != null ) {
			ret.push( value );
		}
	}
}
484
// Flatten any nested arrays
return flat( ret );
},
488
// A global GUID counter for objects
guid: 1,
491
// jQuery.support is not used in Core but other projects attach their
// properties to it so it needs to exist.
support: support
495} );
496
497if ( typeof Symbol === "function" ) {
jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
499}
500
501// Populate the class2type map
502jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
function( _i, name ) {
class2type[ "[object " + name + "]" ] = name.toLowerCase();
} );
506
507function isArrayLike( obj ) {
508
// Support: real iOS 8.2 only (not reproducible in simulator)
// `in` check used to prevent JIT error (gh-2145)
// hasOwn isn't used here due to false negatives
// regarding Nodelist length in IE
var length = !!obj && "length" in obj && obj.length,
type = toType( obj );
515
if ( isFunction( obj ) || isWindow( obj ) ) {
return false;
}
519
return type === "array" || length === 0 ||
typeof length === "number" && length > 0 && ( length - 1 ) in obj;
522}
523var Sizzle =
524/*!
* Sizzle CSS Selector Engine v2.3.9
* https://sizzlejs.com/
*
* Copyright JS Foundation and other contributors
* Released under the MIT license
* https://js.foundation/
*
* Date: 2022-12-19
*/
534( function( window ) {
535var i,
support,
Expr,
getText,
isXML,
tokenize,
compile,
select,
outermostContext,
sortInput,
hasDuplicate,
546
// Local document vars
setDocument,
document,
docElem,
documentIsHTML,
rbuggyQSA,
rbuggyMatches,
matches,
contains,
556
// Instance-specific data
expando = "sizzle" + 1 * new Date(),
preferredDoc = window.document,
dirruns = 0,
done = 0,
classCache = createCache(),
tokenCache = createCache(),
compilerCache = createCache(),
nonnativeSelectorCache = createCache(),
sortOrder = function( a, b ) {
if ( a === b ) {
	hasDuplicate = true;
}
return 0;
},
572
// Instance methods
hasOwn = ( {} ).hasOwnProperty,
arr = [],
pop = arr.pop,
pushNative = arr.push,
push = arr.push,
slice = arr.slice,
580
// Use a stripped-down indexOf as it's faster than native
// https://jsperf.com/thor-indexof-vs-for/5
indexOf = function( list, elem ) {
var i = 0,
	len = list.length;
for ( ; i < len; i++ ) {
	if ( list[ i ] === elem ) {
		return i;
	}
}
return -1;
},
593
booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
"ismap|loop|multiple|open|readonly|required|scoped",
596
// Regular expressions
598
// http://www.w3.org/TR/css3-selectors/#whitespace
whitespace = "[\\x20\\t\\r\\n\\f]",
601
// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
605
// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
608
// Operator (capture 2)
"*([*^$|!~]?=)" + whitespace +
611
// "Attribute values must be CSS identifiers [capture 5]
// or strings [capture 3 or capture 4]"
"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
whitespace + "*\\]",
616
pseudos = ":(" + identifier + ")(?:\\((" +
618
// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
// 1. quoted (capture 3; capture 4 or capture 5)
"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
622
// 2. simple (capture 6)
"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
625
// 3. anything else (capture 2)
".*" +
")\\)|)",
629
// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
rwhitespace = new RegExp( whitespace + "+", "g" ),
rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
whitespace + "+$", "g" ),
634
rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
"*" ),
rdescend = new RegExp( whitespace + "|>" ),
639
rpseudo = new RegExp( pseudos ),
ridentifier = new RegExp( "^" + identifier + "$" ),
642
matchExpr = {
"ID": new RegExp( "^#(" + identifier + ")" ),
"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
"TAG": new RegExp( "^(" + identifier + "|[*])" ),
"ATTR": new RegExp( "^" + attributes ),
"PSEUDO": new RegExp( "^" + pseudos ),
"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
	whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
	whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
653
// For use in libraries implementing .is()
// We use this for POS matching in `select`
"needsContext": new RegExp( "^" + whitespace +
	"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
	"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
},
660
rhtml = /HTML$/i,
rinputs = /^(?:input|select|textarea|button)$/i,
rheader = /^h\d$/i,
664
rnative = /^[^{]+\{\s*\[native \w/,
666
// Easily-parseable/retrievable ID or TAG or CLASS selectors
rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
669
rsibling = /[+~]/,
671
// CSS escapes
// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
funescape = function( escape, nonHex ) {
var high = "0x" + escape.slice( 1 ) - 0x10000;
677
return nonHex ?
679
	// Strip the backslash prefix from a non-hex escape sequence
	nonHex :
682
	// Replace a hexadecimal escape sequence with the encoded Unicode code point
	// Support: IE <=11+
	// For values outside the Basic Multilingual Plane (BMP), manually construct a
	// surrogate pair
	high < 0 ?
		String.fromCharCode( high + 0x10000 ) :
		String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
},
691
// CSS string/identifier serialization
// https://drafts.csswg.org/cssom/#common-serializing-idioms
rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
fcssescape = function( ch, asCodePoint ) {
if ( asCodePoint ) {
697
	// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
	if ( ch === "\0" ) {
		return "\uFFFD";
	}
702
	// Control characters and (dependent upon position) numbers get escaped as code points
	return ch.slice( 0, -1 ) + "\\" +
		ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
}
707
// Other potentially-special ASCII characters get backslash-escaped
return "\\" + ch;
},
711
// Used for iframes
// See setDocument()
// Removing the function wrapper causes a "Permission Denied"
// error in IE
unloadHandler = function() {
setDocument();
},
719
inDisabledFieldset = addCombinator(
function( elem ) {
	return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
},
{ dir: "parentNode", next: "legend" }
);
726
727// Optimize for push.apply( _, NodeList )
728try {
push.apply(
( arr = slice.call( preferredDoc.childNodes ) ),
preferredDoc.childNodes
);
733
// Support: Android<4.0
// Detect silently failing push.apply
// eslint-disable-next-line no-unused-expressions
arr[ preferredDoc.childNodes.length ].nodeType;
738} catch ( e ) {
push = { apply: arr.length ?
740
// Leverage slice if possible
function( target, els ) {
	pushNative.apply( target, slice.call( els ) );
} :
745
// Support: IE<9
// Otherwise append directly
function( target, els ) {
	var j = target.length,
		i = 0;
751
	// Can't trust NodeList.length
	while ( ( target[ j++ ] = els[ i++ ] ) ) {}
	target.length = j - 1;
}
};
757}
758
759function Sizzle( selector, context, results, seed ) {
var m, i, elem, nid, match, groups, newSelector,
newContext = context && context.ownerDocument,
762
// nodeType defaults to 9, since context defaults to document
nodeType = context ? context.nodeType : 9;
765
results = results || [];
767
// Return early from calls with invalid selector or context
if ( typeof selector !== "string" || !selector ||
nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
771
return results;
}
774
// Try to shortcut find operations (as opposed to filters) in HTML documents
if ( !seed ) {
setDocument( context );
context = context || document;
779
if ( documentIsHTML ) {
781
	// If the selector is sufficiently simple, try using a "get*By*" DOM method
	// (excepting DocumentFragment context, where the methods don't exist)
	if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
785
		// ID selector
		if ( ( m = match[ 1 ] ) ) {
788
			// Document context
			if ( nodeType === 9 ) {
				if ( ( elem = context.getElementById( m ) ) ) {
792
					// Support: IE, Opera, Webkit
					// TODO: identify versions
					// getElementById can match elements by name instead of ID
					if ( elem.id === m ) {
						results.push( elem );
						return results;
					}
				} else {
					return results;
				}
803
			// Element context
			} else {
806
				// Support: IE, Opera, Webkit
				// TODO: identify versions
				// getElementById can match elements by name instead of ID
				if ( newContext && ( elem = newContext.getElementById( m ) ) &&
					contains( context, elem ) &&
					elem.id === m ) {
813
					results.push( elem );
					return results;
				}
			}
818
		// Type selector
		} else if ( match[ 2 ] ) {
			push.apply( results, context.getElementsByTagName( selector ) );
			return results;
823
		// Class selector
		} else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&
			context.getElementsByClassName ) {
827
			push.apply( results, context.getElementsByClassName( m ) );
			return results;
		}
	}
832
	// Take advantage of querySelectorAll
	if ( support.qsa &&
		!nonnativeSelectorCache[ selector + " " ] &&
		( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&
837
		// Support: IE 8 only
		// Exclude object elements
		( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) {
841
		newSelector = selector;
		newContext = context;
844
		// qSA considers elements outside a scoping root when evaluating child or
		// descendant combinators, which is not what we want.
		// In such cases, we work around the behavior by prefixing every selector in the
		// list with an ID selector referencing the scope context.
		// The technique has to be used as well when a leading combinator is used
		// as such selectors are not recognized by querySelectorAll.
		// Thanks to Andrew Dupont for this technique.
		if ( nodeType === 1 &&
			( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
854
			// Expand context for sibling selectors
			newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
				context;
858
			// We can use :scope instead of the ID hack if the browser
			// supports it & if we're not changing the context.
			if ( newContext !== context || !support.scope ) {
862
				// Capture the context ID, setting it first if necessary
				if ( ( nid = context.getAttribute( "id" ) ) ) {
					nid = nid.replace( rcssescape, fcssescape );
				} else {
					context.setAttribute( "id", ( nid = expando ) );
				}
			}
870
			// Prefix every selector in the list
			groups = tokenize( selector );
			i = groups.length;
			while ( i-- ) {
				groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
					toSelector( groups[ i ] );
			}
			newSelector = groups.join( "," );
		}
880
		try {
882
			// `qSA` may not throw for unrecognized parts using forgiving parsing:
			// https://drafts.csswg.org/selectors/#forgiving-selector
			// like the `:has()` pseudo-class:
			// https://drafts.csswg.org/selectors/#relational
			// `CSS.supports` is still expected to return `false` then:
			// https://drafts.csswg.org/css-conditional-4/#typedef-supports-selector-fn
			// https://drafts.csswg.org/css-conditional-4/#dfn-support-selector
			if ( support.cssSupportsSelector &&
891
				// eslint-disable-next-line no-undef
				!CSS.supports( "selector(:is(" + newSelector + "))" ) ) {
894
				// Support: IE 11+
				// Throw to get to the same code path as an error directly in qSA.
				// Note: once we only support browser supporting
				// `CSS.supports('selector(...)')`, we can most likely drop
				// the `try-catch`. IE doesn't implement the API.
				throw new Error();
			}
902
			push.apply( results,
				newContext.querySelectorAll( newSelector )
			);
			return results;
		} catch ( qsaError ) {
			nonnativeSelectorCache( selector, true );
		} finally {
			if ( nid === expando ) {
				context.removeAttribute( "id" );
			}
		}
	}
}
}
917
// All others
return select( selector.replace( rtrim, "$1" ), context, results, seed );
920}
921
922/**
* Create key-value caches of limited size
* @returns {function(string, object)} Returns the Object data after storing it on itself with
*	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
*	deleting the oldest entry
*/
928function createCache() {
var keys = [];
930
function cache( key, value ) {
932
// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
if ( keys.push( key + " " ) > Expr.cacheLength ) {
935
	// Only keep the most recent entries
	delete cache[ keys.shift() ];
}
return ( cache[ key + " " ] = value );
}
return cache;
942}
943
944/**
* Mark a function for special use by Sizzle
* @param {Function} fn The function to mark
*/
948function markFunction( fn ) {
fn[ expando ] = true;
return fn;
951}
952
953/**
* Support testing using an element
* @param {Function} fn Passed the created element and returns a boolean result
*/
957function assert( fn ) {
var el = document.createElement( "fieldset" );
959
try {
return !!fn( el );
} catch ( e ) {
return false;
} finally {
965
// Remove from its parent by default
if ( el.parentNode ) {
	el.parentNode.removeChild( el );
}
970
// release memory in IE
el = null;
}
974}
975
976/**
* Adds the same handler for all of the specified attrs
* @param {String} attrs Pipe-separated list of attributes
* @param {Function} handler The method that will be applied
*/
981function addHandle( attrs, handler ) {
var arr = attrs.split( "|" ),
i = arr.length;
984
while ( i-- ) {
Expr.attrHandle[ arr[ i ] ] = handler;
}
988}
989
990/**
* Checks document order of two siblings
* @param {Element} a
* @param {Element} b
* @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
*/
996function siblingCheck( a, b ) {
var cur = b && a,
diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
	a.sourceIndex - b.sourceIndex;
1000
// Use IE sourceIndex if available on both nodes
if ( diff ) {
return diff;
}
1005
// Check if b follows a
if ( cur ) {
while ( ( cur = cur.nextSibling ) ) {
	if ( cur === b ) {
		return -1;
	}
}
}
1014
return a ? 1 : -1;
1016}
1017
1018/**
* Returns a function to use in pseudos for input types
* @param {String} type
*/
1022function createInputPseudo( type ) {
return function( elem ) {
var name = elem.nodeName.toLowerCase();
return name === "input" && elem.type === type;
};
1027}
1028
1029/**
* Returns a function to use in pseudos for buttons
* @param {String} type
*/
1033function createButtonPseudo( type ) {
return function( elem ) {
var name = elem.nodeName.toLowerCase();
return ( name === "input" || name === "button" ) && elem.type === type;
};
1038}
1039
1040/**
* Returns a function to use in pseudos for :enabled/:disabled
* @param {Boolean} disabled true for :disabled; false for :enabled
*/
1044function createDisabledPseudo( disabled ) {
1045
// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
return function( elem ) {
1048
// Only certain elements can match :enabled or :disabled
// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
if ( "form" in elem ) {
1053
	// Check for inherited disabledness on relevant non-disabled elements:
	// * listed form-associated elements in a disabled fieldset
	//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
	//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
	// * option elements in a disabled optgroup
	//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
	// All such elements have a "form" property.
	if ( elem.parentNode && elem.disabled === false ) {
1062
		// Option elements defer to a parent optgroup if present
		if ( "label" in elem ) {
			if ( "label" in elem.parentNode ) {
				return elem.parentNode.disabled === disabled;
			} else {
				return elem.disabled === disabled;
			}
		}
1071
		// Support: IE 6 - 11
		// Use the isDisabled shortcut property to check for disabled fieldset ancestors
		return elem.isDisabled === disabled ||
1075
			// Where there is no isDisabled, check manually
			/* jshint -W018 */
			elem.isDisabled !== !disabled &&
			inDisabledFieldset( elem ) === disabled;
	}
1081
	return elem.disabled === disabled;
1083
// Try to winnow out elements that can't be disabled before trusting the disabled property.
// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
// even exist on them, let alone have a boolean value.
} else if ( "label" in elem ) {
	return elem.disabled === disabled;
}
1090
// Remaining elements are neither :enabled nor :disabled
return false;
};
1094}
1095
1096/**
* Returns a function to use in pseudos for positionals
* @param {Function} fn
*/
1100function createPositionalPseudo( fn ) {
return markFunction( function( argument ) {
argument = +argument;
return markFunction( function( seed, matches ) {
	var j,
		matchIndexes = fn( [], seed.length, argument ),
		i = matchIndexes.length;
1107
	// Match elements found at the specified indexes
	while ( i-- ) {
		if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
			seed[ j ] = !( matches[ j ] = seed[ j ] );
		}
	}
} );
} );
1116}
1117
1118/**
* Checks a node for validity as a Sizzle context
* @param {Element|Object=} context
* @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
*/
1123function testContext( context ) {
return context && typeof context.getElementsByTagName !== "undefined" && context;
1125}
1126
1127// Expose support vars for convenience
1128support = Sizzle.support = {};
1129
1130/**
* Detects XML nodes
* @param {Element|Object} elem An element or a document
* @returns {Boolean} True iff elem is a non-HTML XML node
*/
1135isXML = Sizzle.isXML = function( elem ) {
var namespace = elem && elem.namespaceURI,
docElem = elem && ( elem.ownerDocument || elem ).documentElement;
1138
// Support: IE <=8
// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
// https://bugs.jquery.com/ticket/4833
return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
1143};
1144
1145/**
* Sets document-related variables once based on the current document
* @param {Element|Object} [doc] An element or document object to use to set the document
* @returns {Object} Returns the current document
*/
1150setDocument = Sizzle.setDocument = function( node ) {
var hasCompare, subWindow,
doc = node ? node.ownerDocument || node : preferredDoc;
1153
// Return early if doc is invalid or already selected
// Support: IE 11+, Edge 17 - 18+
// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
// two documents; shallow comparisons work.
// eslint-disable-next-line eqeqeq
if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
return document;
}
1162
// Update global variables
document = doc;
docElem = document.documentElement;
documentIsHTML = !isXML( document );
1167
// Support: IE 9 - 11+, Edge 12 - 18+
// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
// Support: IE 11+, Edge 17 - 18+
// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
// two documents; shallow comparisons work.
// eslint-disable-next-line eqeqeq
if ( preferredDoc != document &&
( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
1176
// Support: IE 11, Edge
if ( subWindow.addEventListener ) {
	subWindow.addEventListener( "unload", unloadHandler, false );
1180
// Support: IE 9 - 10 only
} else if ( subWindow.attachEvent ) {
	subWindow.attachEvent( "onunload", unloadHandler );
}
}
1186
// Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,
// Safari 4 - 5 only, Opera <=11.6 - 12.x only
// IE/Edge & older browsers don't support the :scope pseudo-class.
// Support: Safari 6.0 only
// Safari 6.0 supports :scope but it's an alias of :root there.
support.scope = assert( function( el ) {
docElem.appendChild( el ).appendChild( document.createElement( "div" ) );
return typeof el.querySelectorAll !== "undefined" &&
	!el.querySelectorAll( ":scope fieldset div" ).length;
} );
1197
// Support: Chrome 105+, Firefox 104+, Safari 15.4+
// Make sure forgiving mode is not used in `CSS.supports( "selector(...)" )`.
//
// `:is()` uses a forgiving selector list as an argument and is widely
// implemented, so it's a good one to test against.
support.cssSupportsSelector = assert( function() {
/* eslint-disable no-undef */
1205
return CSS.supports( "selector(*)" ) &&
1207
	// Support: Firefox 78-81 only
	// In old Firefox, `:is()` didn't use forgiving parsing. In that case,
	// fail this test as there's no selector to test against that.
	// `CSS.supports` uses unforgiving parsing
	document.querySelectorAll( ":is(:jqfake)" ) &&
1213
	// `*` is needed as Safari & newer Chrome implemented something in between
	// for `:has()` - it throws in `qSA` if it only contains an unsupported
	// argument but multiple ones, one of which is supported, are fine.
	// We want to play safe in case `:is()` gets the same treatment.
	!CSS.supports( "selector(:is(*,:jqfake))" );
1219
/* eslint-enable */
} );
1222
/* Attributes
---------------------------------------------------------------------- */
1225
// Support: IE<8
// Verify that getAttribute really returns attributes and not properties
// (excepting IE8 booleans)
support.attributes = assert( function( el ) {
el.className = "i";
return !el.getAttribute( "className" );
} );
1233
/* getElement(s)By*
---------------------------------------------------------------------- */
1236
// Check if getElementsByTagName("*") returns only elements
support.getElementsByTagName = assert( function( el ) {
el.appendChild( document.createComment( "" ) );
return !el.getElementsByTagName( "*" ).length;
} );
1242
// Support: IE<9
support.getElementsByClassName = rnative.test( document.getElementsByClassName );
1245
// Support: IE<10
// Check if getElementById returns elements by name
// The broken getElementById methods don't pick up programmatically-set names,
// so use a roundabout getElementsByName test
support.getById = assert( function( el ) {
docElem.appendChild( el ).id = expando;
return !document.getElementsByName || !document.getElementsByName( expando ).length;
} );
1254
// ID filter and find
if ( support.getById ) {
Expr.filter[ "ID" ] = function( id ) {
	var attrId = id.replace( runescape, funescape );
	return function( elem ) {
		return elem.getAttribute( "id" ) === attrId;
	};
};
Expr.find[ "ID" ] = function( id, context ) {
	if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
		var elem = context.getElementById( id );
		return elem ? [ elem ] : [];
	}
};
} else {
Expr.filter[ "ID" ] =  function( id ) {
	var attrId = id.replace( runescape, funescape );
	return function( elem ) {
		var node = typeof elem.getAttributeNode !== "undefined" &&
			elem.getAttributeNode( "id" );
		return node && node.value === attrId;
	};
};
1278
// Support: IE 6 - 7 only
// getElementById is not reliable as a find shortcut
Expr.find[ "ID" ] = function( id, context ) {
	if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
		var node, i, elems,
			elem = context.getElementById( id );
1285
		if ( elem ) {
1287
			// Verify the id attribute
			node = elem.getAttributeNode( "id" );
			if ( node && node.value === id ) {
				return [ elem ];
			}
1293
			// Fall back on getElementsByName
			elems = context.getElementsByName( id );
			i = 0;
			while ( ( elem = elems[ i++ ] ) ) {
				node = elem.getAttributeNode( "id" );
				if ( node && node.value === id ) {
					return [ elem ];
				}
			}
		}
1304
		return [];
	}
};
}
1309
// Tag
Expr.find[ "TAG" ] = support.getElementsByTagName ?
function( tag, context ) {
	if ( typeof context.getElementsByTagName !== "undefined" ) {
		return context.getElementsByTagName( tag );
1315
	// DocumentFragment nodes don't have gEBTN
	} else if ( support.qsa ) {
		return context.querySelectorAll( tag );
	}
} :
1321
function( tag, context ) {
	var elem,
		tmp = [],
		i = 0,
1326
		// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
		results = context.getElementsByTagName( tag );
1329
	// Filter out possible comments
	if ( tag === "*" ) {
		while ( ( elem = results[ i++ ] ) ) {
			if ( elem.nodeType === 1 ) {
				tmp.push( elem );
			}
		}
1337
		return tmp;
	}
	return results;
};
1342
// Class
Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) {
if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
	return context.getElementsByClassName( className );
}
};
1349
/* QSA/matchesSelector
---------------------------------------------------------------------- */
1352
// QSA and matchesSelector support
1354
// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
rbuggyMatches = [];
1357
// qSa(:focus) reports false when true (Chrome 21)
// We allow this because of a bug in IE8/9 that throws an error
// whenever `document.activeElement` is accessed on an iframe
// So, we allow :focus to pass through QSA all the time to avoid the IE error
// See https://bugs.jquery.com/ticket/13378
rbuggyQSA = [];
1364
if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {
1366
// Build QSA regex
// Regex strategy adopted from Diego Perini
assert( function( el ) {
1370
	var input;
1372
	// Select is set to empty string on purpose
	// This is to test IE's treatment of not explicitly
	// setting a boolean content attribute,
	// since its presence should be enough
	// https://bugs.jquery.com/ticket/12359
	docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
		"<select id='" + expando + "-\r\\' msallowcapture=''>" +
		"<option selected=''></option></select>";
1381
	// Support: IE8, Opera 11-12.16
	// Nothing should be selected when empty strings follow ^= or $= or *=
	// The test attribute must be unknown in Opera but "safe" for WinRT
	// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
	if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) {
		rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
	}
1389
	// Support: IE8
	// Boolean attributes and "value" are not treated correctly
	if ( !el.querySelectorAll( "[selected]" ).length ) {
		rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
	}
1395
	// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
	if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
		rbuggyQSA.push( "~=" );
	}
1400
	// Support: IE 11+, Edge 15 - 18+
	// IE 11/Edge don't find elements on a `[name='']` query in some cases.
	// Adding a temporary attribute to the document before the selection works
	// around the issue.
	// Interestingly, IE 10 & older don't seem to have the issue.
	input = document.createElement( "input" );
	input.setAttribute( "name", "" );
	el.appendChild( input );
	if ( !el.querySelectorAll( "[name='']" ).length ) {
		rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
			whitespace + "*(?:''|\"\")" );
	}
1413
	// Webkit/Opera - :checked should return selected option elements
	// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
	// IE8 throws error here and will not see later tests
	if ( !el.querySelectorAll( ":checked" ).length ) {
		rbuggyQSA.push( ":checked" );
	}
1420
	// Support: Safari 8+, iOS 8+
	// https://bugs.webkit.org/show_bug.cgi?id=136851
	// In-page `selector#id sibling-combinator selector` fails
	if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
		rbuggyQSA.push( ".#.+[+~]" );
	}
1427
	// Support: Firefox <=3.6 - 5 only
	// Old Firefox doesn't throw on a badly-escaped identifier.
	el.querySelectorAll( "\\\f" );
	rbuggyQSA.push( "[\\r\\n\\f]" );
} );
1433
assert( function( el ) {
	el.innerHTML = "<a href='' disabled='disabled'></a>" +
		"<select disabled='disabled'><option/></select>";
1437
	// Support: Windows 8 Native Apps
	// The type and name attributes are restricted during .innerHTML assignment
	var input = document.createElement( "input" );
	input.setAttribute( "type", "hidden" );
	el.appendChild( input ).setAttribute( "name", "D" );
1443
	// Support: IE8
	// Enforce case-sensitivity of name attribute
	if ( el.querySelectorAll( "[name=d]" ).length ) {
		rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
	}
1449
	// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
	// IE8 throws error here and will not see later tests
	if ( el.querySelectorAll( ":enabled" ).length !== 2 ) {
		rbuggyQSA.push( ":enabled", ":disabled" );
	}
1455
	// Support: IE9-11+
	// IE's :disabled selector does not pick up the children of disabled fieldsets
	docElem.appendChild( el ).disabled = true;
	if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
		rbuggyQSA.push( ":enabled", ":disabled" );
	}
1462
	// Support: Opera 10 - 11 only
	// Opera 10-11 does not throw on post-comma invalid pseudos
	el.querySelectorAll( "*,:x" );
	rbuggyQSA.push( ",.*:" );
} );
}
1469
if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||
docElem.webkitMatchesSelector ||
docElem.mozMatchesSelector ||
docElem.oMatchesSelector ||
docElem.msMatchesSelector ) ) ) ) {
1475
assert( function( el ) {
1477
	// Check to see if it's possible to do matchesSelector
	// on a disconnected node (IE 9)
	support.disconnectedMatch = matches.call( el, "*" );
1481
	// This should fail with an exception
	// Gecko does not error, returns false instead
	matches.call( el, "[s!='']:x" );
	rbuggyMatches.push( "!=", pseudos );
} );
}
1488
if ( !support.cssSupportsSelector ) {
1490
// Support: Chrome 105+, Safari 15.4+
// `:has()` uses a forgiving selector list as an argument so our regular
// `try-catch` mechanism fails to catch `:has()` with arguments not supported
// natively like `:has(:contains("Foo"))`. Where supported & spec-compliant,
// we now use `CSS.supports("selector(:is(SELECTOR_TO_BE_TESTED))")`, but
// outside that we mark `:has` as buggy.
rbuggyQSA.push( ":has" );
}
1499
rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) );
1502
/* Contains
---------------------------------------------------------------------- */
hasCompare = rnative.test( docElem.compareDocumentPosition );
1506
// Element contains another
// Purposefully self-exclusive
// As in, an element does not contain itself
contains = hasCompare || rnative.test( docElem.contains ) ?
function( a, b ) {
1512
	// Support: IE <9 only
	// IE doesn't have `contains` on `document` so we need to check for
	// `documentElement` presence.
	// We need to fall back to `a` when `documentElement` is missing
	// as `ownerDocument` of elements within `<template/>` may have
	// a null one - a default behavior of all modern browsers.
	var adown = a.nodeType === 9 && a.documentElement || a,
		bup = b && b.parentNode;
	return a === bup || !!( bup && bup.nodeType === 1 && (
		adown.contains ?
			adown.contains( bup ) :
			a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
	) );
} :
function( a, b ) {
	if ( b ) {
		while ( ( b = b.parentNode ) ) {
			if ( b === a ) {
				return true;
			}
		}
	}
	return false;
};
1537
/* Sorting
---------------------------------------------------------------------- */
1540
// Document order sorting
sortOrder = hasCompare ?
function( a, b ) {
1544
// Flag for duplicate removal
if ( a === b ) {
	hasDuplicate = true;
	return 0;
}
1550
// Sort on method existence if only one input has compareDocumentPosition
var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
if ( compare ) {
	return compare;
}
1556
// Calculate position if both inputs belong to the same document
// Support: IE 11+, Edge 17 - 18+
// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
// two documents; shallow comparisons work.
// eslint-disable-next-line eqeqeq
compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
	a.compareDocumentPosition( b ) :
1564
	// Otherwise we know they are disconnected
	1;
1567
// Disconnected nodes
if ( compare & 1 ||
	( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {
1571
	// Choose the first element that is related to our preferred document
	// Support: IE 11+, Edge 17 - 18+
	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
	// two documents; shallow comparisons work.
	// eslint-disable-next-line eqeqeq
	if ( a == document || a.ownerDocument == preferredDoc &&
		contains( preferredDoc, a ) ) {
		return -1;
	}
1581
	// Support: IE 11+, Edge 17 - 18+
	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
	// two documents; shallow comparisons work.
	// eslint-disable-next-line eqeqeq
	if ( b == document || b.ownerDocument == preferredDoc &&
		contains( preferredDoc, b ) ) {
		return 1;
	}
1590
	// Maintain original order
	return sortInput ?
		( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
		0;
}
1596
return compare & 4 ? -1 : 1;
} :
function( a, b ) {
1600
// Exit early if the nodes are identical
if ( a === b ) {
	hasDuplicate = true;
	return 0;
}
1606
var cur,
	i = 0,
	aup = a.parentNode,
	bup = b.parentNode,
	ap = [ a ],
	bp = [ b ];
1613
// Parentless nodes are either documents or disconnected
if ( !aup || !bup ) {
1616
	// Support: IE 11+, Edge 17 - 18+
	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
	// two documents; shallow comparisons work.
	/* eslint-disable eqeqeq */
	return a == document ? -1 :
		b == document ? 1 :
		/* eslint-enable eqeqeq */
		aup ? -1 :
		bup ? 1 :
		sortInput ?
		( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
		0;
1629
// If the nodes are siblings, we can do a quick check
} else if ( aup === bup ) {
	return siblingCheck( a, b );
}
1634
// Otherwise we need full lists of their ancestors for comparison
cur = a;
while ( ( cur = cur.parentNode ) ) {
	ap.unshift( cur );
}
cur = b;
while ( ( cur = cur.parentNode ) ) {
	bp.unshift( cur );
}
1644
// Walk down the tree looking for a discrepancy
while ( ap[ i ] === bp[ i ] ) {
	i++;
}
1649
return i ?
1651
	// Do a sibling check if the nodes have a common ancestor
	siblingCheck( ap[ i ], bp[ i ] ) :
1654
	// Otherwise nodes in our document sort first
	// Support: IE 11+, Edge 17 - 18+
	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
	// two documents; shallow comparisons work.
	/* eslint-disable eqeqeq */
	ap[ i ] == preferredDoc ? -1 :
	bp[ i ] == preferredDoc ? 1 :
	/* eslint-enable eqeqeq */
	0;
};
1665
return document;
1667};
1668
1669Sizzle.matches = function( expr, elements ) {
return Sizzle( expr, null, null, elements );
1671};
1672
1673Sizzle.matchesSelector = function( elem, expr ) {
setDocument( elem );
1675
if ( support.matchesSelector && documentIsHTML &&
!nonnativeSelectorCache[ expr + " " ] &&
( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1680
try {
	var ret = matches.call( elem, expr );
1683
	// IE 9's matchesSelector returns false on disconnected nodes
	if ( ret || support.disconnectedMatch ||
1686
		// As well, disconnected nodes are said to be in a document
		// fragment in IE 9
		elem.document && elem.document.nodeType !== 11 ) {
		return ret;
	}
} catch ( e ) {
	nonnativeSelectorCache( expr, true );
}
}
1696
return Sizzle( expr, document, null, [ elem ] ).length > 0;
1698};
1699
1700Sizzle.contains = function( context, elem ) {
1701
// Set document vars if needed
// Support: IE 11+, Edge 17 - 18+
// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
// two documents; shallow comparisons work.
// eslint-disable-next-line eqeqeq
if ( ( context.ownerDocument || context ) != document ) {
setDocument( context );
}
return contains( context, elem );
1711};
1712
1713Sizzle.attr = function( elem, name ) {
1714
// Set document vars if needed
// Support: IE 11+, Edge 17 - 18+
// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
// two documents; shallow comparisons work.
// eslint-disable-next-line eqeqeq
if ( ( elem.ownerDocument || elem ) != document ) {
setDocument( elem );
}
1723
var fn = Expr.attrHandle[ name.toLowerCase() ],
1725
// Don't get fooled by Object.prototype properties (jQuery #13807)
val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
	fn( elem, name, !documentIsHTML ) :
	undefined;
1730
return val !== undefined ?
val :
support.attributes || !documentIsHTML ?
	elem.getAttribute( name ) :
	( val = elem.getAttributeNode( name ) ) && val.specified ?
		val.value :
		null;
1738};
1739
1740Sizzle.escape = function( sel ) {
return ( sel + "" ).replace( rcssescape, fcssescape );
1742};
1743
1744Sizzle.error = function( msg ) {
throw new Error( "Syntax error, unrecognized expression: " + msg );
1746};
1747
1748/**
* Document sorting and removing duplicates
* @param {ArrayLike} results
*/
1752Sizzle.uniqueSort = function( results ) {
var elem,
duplicates = [],
j = 0,
i = 0;
1757
// Unless we *know* we can detect duplicates, assume their presence
hasDuplicate = !support.detectDuplicates;
sortInput = !support.sortStable && results.slice( 0 );
results.sort( sortOrder );
1762
if ( hasDuplicate ) {
while ( ( elem = results[ i++ ] ) ) {
	if ( elem === results[ i ] ) {
		j = duplicates.push( i );
	}
}
while ( j-- ) {
	results.splice( duplicates[ j ], 1 );
}
}
1773
// Clear input after sorting to release objects
// See https://github.com/jquery/sizzle/pull/225
sortInput = null;
1777
return results;
1779};
1780
1781/**
* Utility function for retrieving the text value of an array of DOM nodes
* @param {Array|Element} elem
*/
1785getText = Sizzle.getText = function( elem ) {
var node,
ret = "",
i = 0,
nodeType = elem.nodeType;
1790
if ( !nodeType ) {
1792
// If no nodeType, this is expected to be an array
while ( ( node = elem[ i++ ] ) ) {
1795
	// Do not traverse comment nodes
	ret += getText( node );
}
} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1800
// Use textContent for elements
// innerText usage removed for consistency of new lines (jQuery #11153)
if ( typeof elem.textContent === "string" ) {
	return elem.textContent;
} else {
1806
	// Traverse its children
	for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
		ret += getText( elem );
	}
}
} else if ( nodeType === 3 || nodeType === 4 ) {
return elem.nodeValue;
}
1815
// Do not include comment or processing instruction nodes
1817
return ret;
1819};
1820
1821Expr = Sizzle.selectors = {
1822
// Can be adjusted by the user
cacheLength: 50,
1825
createPseudo: markFunction,
1827
match: matchExpr,
1829
attrHandle: {},
1831
find: {},
1833
relative: {
">": { dir: "parentNode", first: true },
" ": { dir: "parentNode" },
"+": { dir: "previousSibling", first: true },
"~": { dir: "previousSibling" }
},
1840
preFilter: {
"ATTR": function( match ) {
	match[ 1 ] = match[ 1 ].replace( runescape, funescape );
1844
	// Move the given value to match[3] whether quoted or unquoted
	match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||
		match[ 5 ] || "" ).replace( runescape, funescape );
1848
	if ( match[ 2 ] === "~=" ) {
		match[ 3 ] = " " + match[ 3 ] + " ";
	}
1852
	return match.slice( 0, 4 );
},
1855
"CHILD": function( match ) {
1857
	/* matches from matchExpr["CHILD"]
		1 type (only|nth|...)
		2 what (child|of-type)
		3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
		4 xn-component of xn+y argument ([+-]?\d*n|)
		5 sign of xn-component
		6 x of xn-component
		7 sign of y-component
		8 y of y-component
	*/
	match[ 1 ] = match[ 1 ].toLowerCase();
1869
	if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
1871
		// nth-* requires argument
		if ( !match[ 3 ] ) {
			Sizzle.error( match[ 0 ] );
		}
1876
		// numeric x and y parameters for Expr.filter.CHILD
		// remember that false/true cast respectively to 0/1
		match[ 4 ] = +( match[ 4 ] ?
			match[ 5 ] + ( match[ 6 ] || 1 ) :
			2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) );
		match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
1883
		// other types prohibit arguments
	} else if ( match[ 3 ] ) {
		Sizzle.error( match[ 0 ] );
	}
1888
	return match;
},
1891
"PSEUDO": function( match ) {
	var excess,
		unquoted = !match[ 6 ] && match[ 2 ];
1895
	if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) {
		return null;
	}
1899
	// Accept quoted arguments as-is
	if ( match[ 3 ] ) {
		match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
1903
	// Strip excess characters from unquoted arguments
	} else if ( unquoted && rpseudo.test( unquoted ) &&
1906
		// Get excess from tokenize (recursively)
		( excess = tokenize( unquoted, true ) ) &&
1909
		// advance to the next closing parenthesis
		( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
1912
		// excess is a negative index
		match[ 0 ] = match[ 0 ].slice( 0, excess );
		match[ 2 ] = unquoted.slice( 0, excess );
	}
1917
	// Return only captures needed by the pseudo filter method (type and argument)
	return match.slice( 0, 3 );
}
},
1922
filter: {
1924
"TAG": function( nodeNameSelector ) {
	var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
	return nodeNameSelector === "*" ?
		function() {
			return true;
		} :
		function( elem ) {
			return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
		};
},
1935
"CLASS": function( className ) {
	var pattern = classCache[ className + " " ];
1938
	return pattern ||
		( pattern = new RegExp( "(^|" + whitespace +
			")" + className + "(" + whitespace + "|$)" ) ) && classCache(
				className, function( elem ) {
					return pattern.test(
						typeof elem.className === "string" && elem.className ||
						typeof elem.getAttribute !== "undefined" &&
							elem.getAttribute( "class" ) ||
						""
					);
		} );
},
1951
"ATTR": function( name, operator, check ) {
	return function( elem ) {
		var result = Sizzle.attr( elem, name );
1955
		if ( result == null ) {
			return operator === "!=";
		}
		if ( !operator ) {
			return true;
		}
1962
		result += "";
1964
		/* eslint-disable max-len */
1966
		return operator === "=" ? result === check :
			operator === "!=" ? result !== check :
			operator === "^=" ? check && result.indexOf( check ) === 0 :
			operator === "*=" ? check && result.indexOf( check ) > -1 :
			operator === "$=" ? check && result.slice( -check.length ) === check :
			operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
			operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
			false;
		/* eslint-enable max-len */
1976
	};
},
1979
"CHILD": function( type, what, _argument, first, last ) {
	var simple = type.slice( 0, 3 ) !== "nth",
		forward = type.slice( -4 ) !== "last",
		ofType = what === "of-type";
1984
	return first === 1 && last === 0 ?
1986
		// Shortcut for :nth-*(n)
		function( elem ) {
			return !!elem.parentNode;
		} :
1991
		function( elem, _context, xml ) {
			var cache, uniqueCache, outerCache, node, nodeIndex, start,
				dir = simple !== forward ? "nextSibling" : "previousSibling",
				parent = elem.parentNode,
				name = ofType && elem.nodeName.toLowerCase(),
				useCache = !xml && !ofType,
				diff = false;
1999
			if ( parent ) {
2001
				// :(first|last|only)-(child|of-type)
				if ( simple ) {
					while ( dir ) {
						node = elem;
						while ( ( node = node[ dir ] ) ) {
							if ( ofType ?
								node.nodeName.toLowerCase() === name :
								node.nodeType === 1 ) {
2010
								return false;
							}
						}
2014
						// Reverse direction for :only-* (if we haven't yet done so)
						start = dir = type === "only" && !start && "nextSibling";
					}
					return true;
				}
2020
				start = [ forward ? parent.firstChild : parent.lastChild ];
2022
				// non-xml :nth-child(...) stores cache data on `parent`
				if ( forward && useCache ) {
2025
					// Seek `elem` from a previously-cached index
2027
					// ...in a gzip-friendly way
					node = parent;
					outerCache = node[ expando ] || ( node[ expando ] = {} );
2031
					// Support: IE <9 only
					// Defend against cloned attroperties (jQuery gh-1709)
					uniqueCache = outerCache[ node.uniqueID ] ||
						( outerCache[ node.uniqueID ] = {} );
2036
					cache = uniqueCache[ type ] || [];
					nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
					diff = nodeIndex && cache[ 2 ];
					node = nodeIndex && parent.childNodes[ nodeIndex ];
2041
					while ( ( node = ++nodeIndex && node && node[ dir ] ||
2043
						// Fallback to seeking `elem` from the start
						( diff = nodeIndex = 0 ) || start.pop() ) ) {
2046
						// When found, cache indexes on `parent` and break
						if ( node.nodeType === 1 && ++diff && node === elem ) {
							uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
							break;
						}
					}
2053
				} else {
2055
					// Use previously-cached element index if available
					if ( useCache ) {
2058
						// ...in a gzip-friendly way
						node = elem;
						outerCache = node[ expando ] || ( node[ expando ] = {} );
2062
						// Support: IE <9 only
						// Defend against cloned attroperties (jQuery gh-1709)
						uniqueCache = outerCache[ node.uniqueID ] ||
							( outerCache[ node.uniqueID ] = {} );
2067
						cache = uniqueCache[ type ] || [];
						nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
						diff = nodeIndex;
					}
2072
					// xml :nth-child(...)
					// or :nth-last-child(...) or :nth(-last)?-of-type(...)
					if ( diff === false ) {
2076
						// Use the same loop as above to seek `elem` from the start
						while ( ( node = ++nodeIndex && node && node[ dir ] ||
							( diff = nodeIndex = 0 ) || start.pop() ) ) {
2080
							if ( ( ofType ?
								node.nodeName.toLowerCase() === name :
								node.nodeType === 1 ) &&
								++diff ) {
2085
								// Cache the index of each encountered element
								if ( useCache ) {
									outerCache = node[ expando ] ||
										( node[ expando ] = {} );
2090
									// Support: IE <9 only
									// Defend against cloned attroperties (jQuery gh-1709)
									uniqueCache = outerCache[ node.uniqueID ] ||
										( outerCache[ node.uniqueID ] = {} );
2095
									uniqueCache[ type ] = [ dirruns, diff ];
								}
2098
								if ( node === elem ) {
									break;
								}
							}
						}
					}
				}
2106
				// Incorporate the offset, then check against cycle size
				diff -= last;
				return diff === first || ( diff % first === 0 && diff / first >= 0 );
			}
		};
},
2113
"PSEUDO": function( pseudo, argument ) {
2115
	// pseudo-class names are case-insensitive
	// http://www.w3.org/TR/selectors/#pseudo-classes
	// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
	// Remember that setFilters inherits from pseudos
	var args,
		fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
			Sizzle.error( "unsupported pseudo: " + pseudo );
2123
	// The user may use createPseudo to indicate that
	// arguments are needed to create the filter function
	// just as Sizzle does
	if ( fn[ expando ] ) {
		return fn( argument );
	}
2130
	// But maintain support for old signatures
	if ( fn.length > 1 ) {
		args = [ pseudo, pseudo, "", argument ];
		return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
			markFunction( function( seed, matches ) {
				var idx,
					matched = fn( seed, argument ),
					i = matched.length;
				while ( i-- ) {
					idx = indexOf( seed, matched[ i ] );
					seed[ idx ] = !( matches[ idx ] = matched[ i ] );
				}
			} ) :
			function( elem ) {
				return fn( elem, 0, args );
			};
	}
2148
	return fn;
}
},
2152
pseudos: {
2154
// Potentially complex pseudos
"not": markFunction( function( selector ) {
2157
	// Trim the selector passed to compile
	// to avoid treating leading and trailing
	// spaces as combinators
	var input = [],
		results = [],
		matcher = compile( selector.replace( rtrim, "$1" ) );
2164
	return matcher[ expando ] ?
		markFunction( function( seed, matches, _context, xml ) {
			var elem,
				unmatched = matcher( seed, null, xml, [] ),
				i = seed.length;
2170
			// Match elements unmatched by `matcher`
			while ( i-- ) {
				if ( ( elem = unmatched[ i ] ) ) {
					seed[ i ] = !( matches[ i ] = elem );
				}
			}
		} ) :
		function( elem, _context, xml ) {
			input[ 0 ] = elem;
			matcher( input, null, xml, results );
2181
			// Don't keep the element (issue #299)
			input[ 0 ] = null;
			return !results.pop();
		};
} ),
2187
"has": markFunction( function( selector ) {
	return function( elem ) {
		return Sizzle( selector, elem ).length > 0;
	};
} ),
2193
"contains": markFunction( function( text ) {
	text = text.replace( runescape, funescape );
	return function( elem ) {
		return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
	};
} ),
2200
// "Whether an element is represented by a :lang() selector
// is based solely on the element's language value
// being equal to the identifier C,
// or beginning with the identifier C immediately followed by "-".
// The matching of C against the element's language value is performed case-insensitively.
// The identifier C does not have to be a valid language name."
// http://www.w3.org/TR/selectors/#lang-pseudo
"lang": markFunction( function( lang ) {
2209
	// lang value must be a valid identifier
	if ( !ridentifier.test( lang || "" ) ) {
		Sizzle.error( "unsupported lang: " + lang );
	}
	lang = lang.replace( runescape, funescape ).toLowerCase();
	return function( elem ) {
		var elemLang;
		do {
			if ( ( elemLang = documentIsHTML ?
				elem.lang :
				elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
2221
				elemLang = elemLang.toLowerCase();
				return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
			}
		} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
		return false;
	};
} ),
2229
// Miscellaneous
"target": function( elem ) {
	var hash = window.location && window.location.hash;
	return hash && hash.slice( 1 ) === elem.id;
},
2235
"root": function( elem ) {
	return elem === docElem;
},
2239
"focus": function( elem ) {
	return elem === document.activeElement &&
		( !document.hasFocus || document.hasFocus() ) &&
		!!( elem.type || elem.href || ~elem.tabIndex );
},
2245
// Boolean properties
"enabled": createDisabledPseudo( false ),
"disabled": createDisabledPseudo( true ),
2249
"checked": function( elem ) {
2251
	// In CSS3, :checked should return both checked and selected elements
	// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
	var nodeName = elem.nodeName.toLowerCase();
	return ( nodeName === "input" && !!elem.checked ) ||
		( nodeName === "option" && !!elem.selected );
},
2258
"selected": function( elem ) {
2260
	// Accessing this property makes selected-by-default
	// options in Safari work properly
	if ( elem.parentNode ) {
		// eslint-disable-next-line no-unused-expressions
		elem.parentNode.selectedIndex;
	}
2267
	return elem.selected === true;
},
2270
// Contents
"empty": function( elem ) {
2273
	// http://www.w3.org/TR/selectors/#empty-pseudo
	// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
	//   but not by others (comment: 8; processing instruction: 7; etc.)
	// nodeType < 6 works because attributes (2) do not appear as children
	for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
		if ( elem.nodeType < 6 ) {
			return false;
		}
	}
	return true;
},
2285
"parent": function( elem ) {
	return !Expr.pseudos[ "empty" ]( elem );
},
2289
// Element/input types
"header": function( elem ) {
	return rheader.test( elem.nodeName );
},
2294
"input": function( elem ) {
	return rinputs.test( elem.nodeName );
},
2298
"button": function( elem ) {
	var name = elem.nodeName.toLowerCase();
	return name === "input" && elem.type === "button" || name === "button";
},
2303
"text": function( elem ) {
	var attr;
	return elem.nodeName.toLowerCase() === "input" &&
		elem.type === "text" &&
2308
		// Support: IE <10 only
		// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
		( ( attr = elem.getAttribute( "type" ) ) == null ||
			attr.toLowerCase() === "text" );
},
2314
// Position-in-collection
"first": createPositionalPseudo( function() {
	return [ 0 ];
} ),
2319
"last": createPositionalPseudo( function( _matchIndexes, length ) {
	return [ length - 1 ];
} ),
2323
"eq": createPositionalPseudo( function( _matchIndexes, length, argument ) {
	return [ argument < 0 ? argument + length : argument ];
} ),
2327
"even": createPositionalPseudo( function( matchIndexes, length ) {
	var i = 0;
	for ( ; i < length; i += 2 ) {
		matchIndexes.push( i );
	}
	return matchIndexes;
} ),
2335
"odd": createPositionalPseudo( function( matchIndexes, length ) {
	var i = 1;
	for ( ; i < length; i += 2 ) {
		matchIndexes.push( i );
	}
	return matchIndexes;
} ),
2343
"lt": createPositionalPseudo( function( matchIndexes, length, argument ) {
	var i = argument < 0 ?
		argument + length :
		argument > length ?
			length :
			argument;
	for ( ; --i >= 0; ) {
		matchIndexes.push( i );
	}
	return matchIndexes;
} ),
2355
"gt": createPositionalPseudo( function( matchIndexes, length, argument ) {
	var i = argument < 0 ? argument + length : argument;
	for ( ; ++i < length; ) {
		matchIndexes.push( i );
	}
	return matchIndexes;
} )
}
2364};
2365
2366Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ];
2367
2368// Add button/input type pseudos
2369for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
Expr.pseudos[ i ] = createInputPseudo( i );
2371}
2372for ( i in { submit: true, reset: true } ) {
Expr.pseudos[ i ] = createButtonPseudo( i );
2374}
2375
2376// Easy API for creating new setFilters
2377function setFilters() {}
2378setFilters.prototype = Expr.filters = Expr.pseudos;
2379Expr.setFilters = new setFilters();
2380
2381tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
var matched, match, tokens, type,
soFar, groups, preFilters,
cached = tokenCache[ selector + " " ];
2385
if ( cached ) {
return parseOnly ? 0 : cached.slice( 0 );
}
2389
soFar = selector;
groups = [];
preFilters = Expr.preFilter;
2393
while ( soFar ) {
2395
// Comma and first run
if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
	if ( match ) {
2399
		// Don't consume trailing commas as valid
		soFar = soFar.slice( match[ 0 ].length ) || soFar;
	}
	groups.push( ( tokens = [] ) );
}
2405
matched = false;
2407
// Combinators
if ( ( match = rcombinators.exec( soFar ) ) ) {
	matched = match.shift();
	tokens.push( {
		value: matched,
2413
		// Cast descendant combinators to space
		type: match[ 0 ].replace( rtrim, " " )
	} );
	soFar = soFar.slice( matched.length );
}
2419
// Filters
for ( type in Expr.filter ) {
	if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
		( match = preFilters[ type ]( match ) ) ) ) {
		matched = match.shift();
		tokens.push( {
			value: matched,
			type: type,
			matches: match
		} );
		soFar = soFar.slice( matched.length );
	}
}
2433
if ( !matched ) {
	break;
}
}
2438
// Return the length of the invalid excess
// if we're just parsing
// Otherwise, throw an error or return tokens
return parseOnly ?
soFar.length :
soFar ?
	Sizzle.error( selector ) :
2446
	// Cache the tokens
	tokenCache( selector, groups ).slice( 0 );
2449};
2450
2451function toSelector( tokens ) {
var i = 0,
len = tokens.length,
selector = "";
for ( ; i < len; i++ ) {
selector += tokens[ i ].value;
}
return selector;
2459}
2460
2461function addCombinator( matcher, combinator, base ) {
var dir = combinator.dir,
skip = combinator.next,
key = skip || dir,
checkNonElements = base && key === "parentNode",
doneName = done++;
2467
return combinator.first ?
2469
// Check against closest ancestor/preceding element
function( elem, context, xml ) {
	while ( ( elem = elem[ dir ] ) ) {
		if ( elem.nodeType === 1 || checkNonElements ) {
			return matcher( elem, context, xml );
		}
	}
	return false;
} :
2479
// Check against all ancestor/preceding elements
function( elem, context, xml ) {
	var oldCache, uniqueCache, outerCache,
		newCache = [ dirruns, doneName ];
2484
	// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
	if ( xml ) {
		while ( ( elem = elem[ dir ] ) ) {
			if ( elem.nodeType === 1 || checkNonElements ) {
				if ( matcher( elem, context, xml ) ) {
					return true;
				}
			}
		}
	} else {
		while ( ( elem = elem[ dir ] ) ) {
			if ( elem.nodeType === 1 || checkNonElements ) {
				outerCache = elem[ expando ] || ( elem[ expando ] = {} );
2498
				// Support: IE <9 only
				// Defend against cloned attroperties (jQuery gh-1709)
				uniqueCache = outerCache[ elem.uniqueID ] ||
					( outerCache[ elem.uniqueID ] = {} );
2503
				if ( skip && skip === elem.nodeName.toLowerCase() ) {
					elem = elem[ dir ] || elem;
				} else if ( ( oldCache = uniqueCache[ key ] ) &&
					oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2508
					// Assign to newCache so results back-propagate to previous elements
					return ( newCache[ 2 ] = oldCache[ 2 ] );
				} else {
2512
					// Reuse newcache so results back-propagate to previous elements
					uniqueCache[ key ] = newCache;
2515
					// A match means we're done; a fail means we have to keep checking
					if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
						return true;
					}
				}
			}
		}
	}
	return false;
};
2526}
2527
2528function elementMatcher( matchers ) {
return matchers.length > 1 ?
function( elem, context, xml ) {
	var i = matchers.length;
	while ( i-- ) {
		if ( !matchers[ i ]( elem, context, xml ) ) {
			return false;
		}
	}
	return true;
} :
matchers[ 0 ];
2540}
2541
2542function multipleContexts( selector, contexts, results ) {
var i = 0,
len = contexts.length;
for ( ; i < len; i++ ) {
Sizzle( selector, contexts[ i ], results );
}
return results;
2549}
2550
2551function condense( unmatched, map, filter, context, xml ) {
var elem,
newUnmatched = [],
i = 0,
len = unmatched.length,
mapped = map != null;
2557
for ( ; i < len; i++ ) {
if ( ( elem = unmatched[ i ] ) ) {
	if ( !filter || filter( elem, context, xml ) ) {
		newUnmatched.push( elem );
		if ( mapped ) {
			map.push( i );
		}
	}
}
}
2568
return newUnmatched;
2570}
2571
2572function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
if ( postFilter && !postFilter[ expando ] ) {
postFilter = setMatcher( postFilter );
}
if ( postFinder && !postFinder[ expando ] ) {
postFinder = setMatcher( postFinder, postSelector );
}
return markFunction( function( seed, results, context, xml ) {
var temp, i, elem,
	preMap = [],
	postMap = [],
	preexisting = results.length,
2584
	// Get initial elements from seed or context
	elems = seed || multipleContexts(
		selector || "*",
		context.nodeType ? [ context ] : context,
		[]
	),
2591
	// Prefilter to get matcher input, preserving a map for seed-results synchronization
	matcherIn = preFilter && ( seed || !selector ) ?
		condense( elems, preMap, preFilter, context, xml ) :
		elems,
2596
	matcherOut = matcher ?
2598
		// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
		postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2601
			// ...intermediate processing is necessary
			[] :
2604
			// ...otherwise use results directly
			results :
		matcherIn;
2608
// Find primary matches
if ( matcher ) {
	matcher( matcherIn, matcherOut, context, xml );
}
2613
// Apply postFilter
if ( postFilter ) {
	temp = condense( matcherOut, postMap );
	postFilter( temp, [], context, xml );
2618
	// Un-match failing elements by moving them back to matcherIn
	i = temp.length;
	while ( i-- ) {
		if ( ( elem = temp[ i ] ) ) {
			matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
		}
	}
}
2627
if ( seed ) {
	if ( postFinder || preFilter ) {
		if ( postFinder ) {
2631
			// Get the final matcherOut by condensing this intermediate into postFinder contexts
			temp = [];
			i = matcherOut.length;
			while ( i-- ) {
				if ( ( elem = matcherOut[ i ] ) ) {
2637
					// Restore matcherIn since elem is not yet a final match
					temp.push( ( matcherIn[ i ] = elem ) );
				}
			}
			postFinder( null, ( matcherOut = [] ), temp, xml );
		}
2644
		// Move matched elements from seed to results to keep them synchronized
		i = matcherOut.length;
		while ( i-- ) {
			if ( ( elem = matcherOut[ i ] ) &&
				( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {
2650
				seed[ temp ] = !( results[ temp ] = elem );
			}
		}
	}
2655
// Add elements to results, through postFinder if defined
} else {
	matcherOut = condense(
		matcherOut === results ?
			matcherOut.splice( preexisting, matcherOut.length ) :
			matcherOut
	);
	if ( postFinder ) {
		postFinder( null, results, matcherOut, xml );
	} else {
		push.apply( results, matcherOut );
	}
}
} );
2670}
2671
2672function matcherFromTokens( tokens ) {
var checkContext, matcher, j,
len = tokens.length,
leadingRelative = Expr.relative[ tokens[ 0 ].type ],
implicitRelative = leadingRelative || Expr.relative[ " " ],
i = leadingRelative ? 1 : 0,
2678
// The foundational matcher ensures that elements are reachable from top-level context(s)
matchContext = addCombinator( function( elem ) {
	return elem === checkContext;
}, implicitRelative, true ),
matchAnyContext = addCombinator( function( elem ) {
	return indexOf( checkContext, elem ) > -1;
}, implicitRelative, true ),
matchers = [ function( elem, context, xml ) {
	var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
		( checkContext = context ).nodeType ?
			matchContext( elem, context, xml ) :
			matchAnyContext( elem, context, xml ) );
2691
	// Avoid hanging onto element (issue #299)
	checkContext = null;
	return ret;
} ];
2696
for ( ; i < len; i++ ) {
if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
	matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
} else {
	matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
2702
	// Return special upon seeing a positional matcher
	if ( matcher[ expando ] ) {
2705
		// Find the next relative operator (if any) for proper handling
		j = ++i;
		for ( ; j < len; j++ ) {
			if ( Expr.relative[ tokens[ j ].type ] ) {
				break;
			}
		}
		return setMatcher(
			i > 1 && elementMatcher( matchers ),
			i > 1 && toSelector(
2716
			// If the preceding token was a descendant combinator, insert an implicit any-element `*`
			tokens
				.slice( 0, i - 1 )
				.concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
			).replace( rtrim, "$1" ),
			matcher,
			i < j && matcherFromTokens( tokens.slice( i, j ) ),
			j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
			j < len && toSelector( tokens )
		);
	}
	matchers.push( matcher );
}
}
2731
return elementMatcher( matchers );
2733}
2734
2735function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
var bySet = setMatchers.length > 0,
byElement = elementMatchers.length > 0,
superMatcher = function( seed, context, xml, results, outermost ) {
	var elem, j, matcher,
		matchedCount = 0,
		i = "0",
		unmatched = seed && [],
		setMatched = [],
		contextBackup = outermostContext,
2745
		// We must always have either seed elements or outermost context
		elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ),
2748
		// Use integer dirruns iff this is the outermost matcher
		dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
		len = elems.length;
2752
	if ( outermost ) {
2754
		// Support: IE 11+, Edge 17 - 18+
		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
		// two documents; shallow comparisons work.
		// eslint-disable-next-line eqeqeq
		outermostContext = context == document || context || outermost;
	}
2761
	// Add elements passing elementMatchers directly to results
	// Support: IE<9, Safari
	// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
	for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
		if ( byElement && elem ) {
			j = 0;
2768
			// Support: IE 11+, Edge 17 - 18+
			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
			// two documents; shallow comparisons work.
			// eslint-disable-next-line eqeqeq
			if ( !context && elem.ownerDocument != document ) {
				setDocument( elem );
				xml = !documentIsHTML;
			}
			while ( ( matcher = elementMatchers[ j++ ] ) ) {
				if ( matcher( elem, context || document, xml ) ) {
					results.push( elem );
					break;
				}
			}
			if ( outermost ) {
				dirruns = dirrunsUnique;
			}
		}
2787
		// Track unmatched elements for set filters
		if ( bySet ) {
2790
			// They will have gone through all possible matchers
			if ( ( elem = !matcher && elem ) ) {
				matchedCount--;
			}
2795
			// Lengthen the array for every element, matched or not
			if ( seed ) {
				unmatched.push( elem );
			}
		}
	}
2802
	// `i` is now the count of elements visited above, and adding it to `matchedCount`
	// makes the latter nonnegative.
	matchedCount += i;
2806
	// Apply set filters to unmatched elements
	// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
	// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
	// no element matchers and no seed.
	// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
	// case, which will result in a "00" `matchedCount` that differs from `i` but is also
	// numerically zero.
	if ( bySet && i !== matchedCount ) {
		j = 0;
		while ( ( matcher = setMatchers[ j++ ] ) ) {
			matcher( unmatched, setMatched, context, xml );
		}
2819
		if ( seed ) {
2821
			// Reintegrate element matches to eliminate the need for sorting
			if ( matchedCount > 0 ) {
				while ( i-- ) {
					if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
						setMatched[ i ] = pop.call( results );
					}
				}
			}
2830
			// Discard index placeholder values to get only actual matches
			setMatched = condense( setMatched );
		}
2834
		// Add matches to results
		push.apply( results, setMatched );
2837
		// Seedless set matches succeeding multiple successful matchers stipulate sorting
		if ( outermost && !seed && setMatched.length > 0 &&
			( matchedCount + setMatchers.length ) > 1 ) {
2841
			Sizzle.uniqueSort( results );
		}
	}
2845
	// Override manipulation of globals by nested matchers
	if ( outermost ) {
		dirruns = dirrunsUnique;
		outermostContext = contextBackup;
	}
2851
	return unmatched;
};
2854
return bySet ?
markFunction( superMatcher ) :
superMatcher;
2858}
2859
2860compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
var i,
setMatchers = [],
elementMatchers = [],
cached = compilerCache[ selector + " " ];
2865
if ( !cached ) {
2867
// Generate a function of recursive functions that can be used to check each element
if ( !match ) {
	match = tokenize( selector );
}
i = match.length;
while ( i-- ) {
	cached = matcherFromTokens( match[ i ] );
	if ( cached[ expando ] ) {
		setMatchers.push( cached );
	} else {
		elementMatchers.push( cached );
	}
}
2881
// Cache the compiled function
cached = compilerCache(
	selector,
	matcherFromGroupMatchers( elementMatchers, setMatchers )
);
2887
// Save selector and tokenization
cached.selector = selector;
}
return cached;
2892};
2893
2894/**
* A low-level selection function that works with Sizzle's compiled
*  selector functions
* @param {String|Function} selector A selector or a pre-compiled
*  selector function built with Sizzle.compile
* @param {Element} context
* @param {Array} [results]
* @param {Array} [seed] A set of elements to match against
*/
2903select = Sizzle.select = function( selector, context, results, seed ) {
var i, tokens, token, type, find,
compiled = typeof selector === "function" && selector,
match = !seed && tokenize( ( selector = compiled.selector || selector ) );
2907
results = results || [];
2909
// Try to minimize operations if there is only one selector in the list and no seed
// (the latter of which guarantees us context)
if ( match.length === 1 ) {
2913
// Reduce context if the leading compound selector is an ID
tokens = match[ 0 ] = match[ 0 ].slice( 0 );
if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
	context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
2918
	context = ( Expr.find[ "ID" ]( token.matches[ 0 ]
		.replace( runescape, funescape ), context ) || [] )[ 0 ];
	if ( !context ) {
		return results;
2923
	// Precompiled matchers will still verify ancestry, so step up a level
	} else if ( compiled ) {
		context = context.parentNode;
	}
2928
	selector = selector.slice( tokens.shift().value.length );
}
2931
// Fetch a seed set for right-to-left matching
i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length;
while ( i-- ) {
	token = tokens[ i ];
2936
	// Abort if we hit a combinator
	if ( Expr.relative[ ( type = token.type ) ] ) {
		break;
	}
	if ( ( find = Expr.find[ type ] ) ) {
2942
		// Search, expanding context for leading sibling combinators
		if ( ( seed = find(
			token.matches[ 0 ].replace( runescape, funescape ),
			rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||
				context
		) ) ) {
2949
			// If seed is empty or no tokens remain, we can return early
			tokens.splice( i, 1 );
			selector = seed.length && toSelector( tokens );
			if ( !selector ) {
				push.apply( results, seed );
				return results;
			}
2957
			break;
		}
	}
}
}
2963
// Compile and execute a filtering function if one is not provided
// Provide `match` to avoid retokenization if we modified the selector above
( compiled || compile( selector, match ) )(
seed,
context,
!documentIsHTML,
results,
!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
);
return results;
2974};
2975
2976// One-time assignments
2977
2978// Sort stability
2979support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
2980
2981// Support: Chrome 14-35+
2982// Always assume duplicates if they aren't passed to the comparison function
2983support.detectDuplicates = !!hasDuplicate;
2984
2985// Initialize against the default document
2986setDocument();
2987
2988// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2989// Detached nodes confoundingly follow *each other*
2990support.sortDetached = assert( function( el ) {
2991
// Should return 1, but returns 4 (following)
return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
2994} );
2995
2996// Support: IE<8
2997// Prevent attribute/property "interpolation"
2998// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2999if ( !assert( function( el ) {
el.innerHTML = "<a href='#'></a>";
return el.firstChild.getAttribute( "href" ) === "#";
3002} ) ) {
addHandle( "type|href|height|width", function( elem, name, isXML ) {
if ( !isXML ) {
	return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
}
} );
3008}
3009
3010// Support: IE<9
3011// Use defaultValue in place of getAttribute("value")
3012if ( !support.attributes || !assert( function( el ) {
el.innerHTML = "<input/>";
el.firstChild.setAttribute( "value", "" );
return el.firstChild.getAttribute( "value" ) === "";
3016} ) ) {
addHandle( "value", function( elem, _name, isXML ) {
if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
	return elem.defaultValue;
}
} );
3022}
3023
3024// Support: IE<9
3025// Use getAttributeNode to fetch booleans when getAttribute lies
3026if ( !assert( function( el ) {
return el.getAttribute( "disabled" ) == null;
3028} ) ) {
addHandle( booleans, function( elem, name, isXML ) {
var val;
if ( !isXML ) {
	return elem[ name ] === true ? name.toLowerCase() :
		( val = elem.getAttributeNode( name ) ) && val.specified ?
			val.value :
			null;
}
} );
3038}
3039
3040return Sizzle;
3041
3042} )( window );
3043
3044
3045
3046jQuery.find = Sizzle;
3047jQuery.expr = Sizzle.selectors;
3048
3049// Deprecated
3050jQuery.expr[ ":" ] = jQuery.expr.pseudos;
3051jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
3052jQuery.text = Sizzle.getText;
3053jQuery.isXMLDoc = Sizzle.isXML;
3054jQuery.contains = Sizzle.contains;
3055jQuery.escapeSelector = Sizzle.escape;
3056
3057
3058
3059
3060var dir = function( elem, dir, until ) {
var matched = [],
truncate = until !== undefined;
3063
while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
if ( elem.nodeType === 1 ) {
	if ( truncate && jQuery( elem ).is( until ) ) {
		break;
	}
	matched.push( elem );
}
}
return matched;
3073};
3074
3075
3076var siblings = function( n, elem ) {
var matched = [];
3078
for ( ; n; n = n.nextSibling ) {
if ( n.nodeType === 1 && n !== elem ) {
	matched.push( n );
}
}
3084
return matched;
3086};
3087
3088
3089var rneedsContext = jQuery.expr.match.needsContext;
3090
3091
3092
3093function nodeName( elem, name ) {
3094
return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
3096
3097}
3098var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
3099
3100
3101
3102// Implement the identical functionality for filter and not
3103function winnow( elements, qualifier, not ) {
if ( isFunction( qualifier ) ) {
return jQuery.grep( elements, function( elem, i ) {
	return !!qualifier.call( elem, i, elem ) !== not;
} );
}
3109
// Single element
if ( qualifier.nodeType ) {
return jQuery.grep( elements, function( elem ) {
	return ( elem === qualifier ) !== not;
} );
}
3116
// Arraylike of elements (jQuery, arguments, Array)
if ( typeof qualifier !== "string" ) {
return jQuery.grep( elements, function( elem ) {
	return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
} );
}
3123
// Filtered directly for both simple and complex selectors
return jQuery.filter( qualifier, elements, not );
3126}
3127
3128jQuery.filter = function( expr, elems, not ) {
var elem = elems[ 0 ];
3130
if ( not ) {
expr = ":not(" + expr + ")";
}
3134
if ( elems.length === 1 && elem.nodeType === 1 ) {
return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
}
3138
return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
return elem.nodeType === 1;
} ) );
3142};
3143
3144jQuery.fn.extend( {
find: function( selector ) {
var i, ret,
	len = this.length,
	self = this;
3149
if ( typeof selector !== "string" ) {
	return this.pushStack( jQuery( selector ).filter( function() {
		for ( i = 0; i < len; i++ ) {
			if ( jQuery.contains( self[ i ], this ) ) {
				return true;
			}
		}
	} ) );
}
3159
ret = this.pushStack( [] );
3161
for ( i = 0; i < len; i++ ) {
	jQuery.find( selector, self[ i ], ret );
}
3165
return len > 1 ? jQuery.uniqueSort( ret ) : ret;
},
filter: function( selector ) {
return this.pushStack( winnow( this, selector || [], false ) );
},
not: function( selector ) {
return this.pushStack( winnow( this, selector || [], true ) );
},
is: function( selector ) {
return !!winnow(
	this,
3177
	// If this is a positional/relative selector, check membership in the returned set
	// so $("p:first").is("p:last") won't return true for a doc with two "p".
	typeof selector === "string" && rneedsContext.test( selector ) ?
		jQuery( selector ) :
		selector || [],
	false
).length;
}
3186} );
3187
3188
3189// Initialize a jQuery object
3190
3191
3192// A central reference to the root jQuery(document)
3193var rootjQuery,
3194
// A simple way to check for HTML strings
// Prioritize #id over <tag> to avoid XSS via location.hash (trac-9521)
// Strict HTML recognition (trac-11290: must start with <)
// Shortcut simple #id case for speed
rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
3200
init = jQuery.fn.init = function( selector, context, root ) {
var match, elem;
3203
// HANDLE: $(""), $(null), $(undefined), $(false)
if ( !selector ) {
	return this;
}
3208
// Method init() accepts an alternate rootjQuery
// so migrate can support jQuery.sub (gh-2101)
root = root || rootjQuery;
3212
// Handle HTML strings
if ( typeof selector === "string" ) {
	if ( selector[ 0 ] === "<" &&
		selector[ selector.length - 1 ] === ">" &&
		selector.length >= 3 ) {
3218
		// Assume that strings that start and end with <> are HTML and skip the regex check
		match = [ null, selector, null ];
3221
	} else {
		match = rquickExpr.exec( selector );
	}
3225
	// Match html or make sure no context is specified for #id
	if ( match && ( match[ 1 ] || !context ) ) {
3228
		// HANDLE: $(html) -> $(array)
		if ( match[ 1 ] ) {
			context = context instanceof jQuery ? context[ 0 ] : context;
3232
			// Option to run scripts is true for back-compat
			// Intentionally let the error be thrown if parseHTML is not present
			jQuery.merge( this, jQuery.parseHTML(
				match[ 1 ],
				context && context.nodeType ? context.ownerDocument || context : document,
				true
			) );
3240
			// HANDLE: $(html, props)
			if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
				for ( match in context ) {
3244
					// Properties of context are called as methods if possible
					if ( isFunction( this[ match ] ) ) {
						this[ match ]( context[ match ] );
3248
					// ...and otherwise set as attributes
					} else {
						this.attr( match, context[ match ] );
					}
				}
			}
3255
			return this;
3257
		// HANDLE: $(#id)
		} else {
			elem = document.getElementById( match[ 2 ] );
3261
			if ( elem ) {
3263
				// Inject the element directly into the jQuery object
				this[ 0 ] = elem;
				this.length = 1;
			}
			return this;
		}
3270
	// HANDLE: $(expr, $(...))
	} else if ( !context || context.jquery ) {
		return ( context || root ).find( selector );
3274
	// HANDLE: $(expr, context)
	// (which is just equivalent to: $(context).find(expr)
	} else {
		return this.constructor( context ).find( selector );
	}
3280
// HANDLE: $(DOMElement)
} else if ( selector.nodeType ) {
	this[ 0 ] = selector;
	this.length = 1;
	return this;
3286
// HANDLE: $(function)
// Shortcut for document ready
} else if ( isFunction( selector ) ) {
	return root.ready !== undefined ?
		root.ready( selector ) :
3292
		// Execute immediately if ready is not present
		selector( jQuery );
}
3296
return jQuery.makeArray( selector, this );
};
3299
3300// Give the init function the jQuery prototype for later instantiation
3301init.prototype = jQuery.fn;
3302
3303// Initialize central reference
3304rootjQuery = jQuery( document );
3305
3306
3307var rparentsprev = /^(?:parents|prev(?:Until|All))/,
3308
// Methods guaranteed to produce a unique set when starting from a unique set
guaranteedUnique = {
children: true,
contents: true,
next: true,
prev: true
};
3316
3317jQuery.fn.extend( {
has: function( target ) {
var targets = jQuery( target, this ),
	l = targets.length;
3321
return this.filter( function() {
	var i = 0;
	for ( ; i < l; i++ ) {
		if ( jQuery.contains( this, targets[ i ] ) ) {
			return true;
		}
	}
} );
},
3331
closest: function( selectors, context ) {
var cur,
	i = 0,
	l = this.length,
	matched = [],
	targets = typeof selectors !== "string" && jQuery( selectors );
3338
// Positional selectors never match, since there's no _selection_ context
if ( !rneedsContext.test( selectors ) ) {
	for ( ; i < l; i++ ) {
		for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
3343
			// Always skip document fragments
			if ( cur.nodeType < 11 && ( targets ?
				targets.index( cur ) > -1 :
3347
				// Don't pass non-elements to Sizzle
				cur.nodeType === 1 &&
					jQuery.find.matchesSelector( cur, selectors ) ) ) {
3351
				matched.push( cur );
				break;
			}
		}
	}
}
3358
return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
},
3361
// Determine the position of an element within the set
index: function( elem ) {
3364
// No argument, return index in parent
if ( !elem ) {
	return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
}
3369
// Index in selector
if ( typeof elem === "string" ) {
	return indexOf.call( jQuery( elem ), this[ 0 ] );
}
3374
// Locate the position of the desired element
return indexOf.call( this,
3377
	// If it receives a jQuery object, the first element is used
	elem.jquery ? elem[ 0 ] : elem
);
},
3382
add: function( selector, context ) {
return this.pushStack(
	jQuery.uniqueSort(
		jQuery.merge( this.get(), jQuery( selector, context ) )
	)
);
},
3390
addBack: function( selector ) {
return this.add( selector == null ?
	this.prevObject : this.prevObject.filter( selector )
);
}
3396} );
3397
3398function sibling( cur, dir ) {
while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
return cur;
3401}
3402
3403jQuery.each( {
parent: function( elem ) {
var parent = elem.parentNode;
return parent && parent.nodeType !== 11 ? parent : null;
},
parents: function( elem ) {
return dir( elem, "parentNode" );
},
parentsUntil: function( elem, _i, until ) {
return dir( elem, "parentNode", until );
},
next: function( elem ) {
return sibling( elem, "nextSibling" );
},
prev: function( elem ) {
return sibling( elem, "previousSibling" );
},
nextAll: function( elem ) {
return dir( elem, "nextSibling" );
},
prevAll: function( elem ) {
return dir( elem, "previousSibling" );
},
nextUntil: function( elem, _i, until ) {
return dir( elem, "nextSibling", until );
},
prevUntil: function( elem, _i, until ) {
return dir( elem, "previousSibling", until );
},
siblings: function( elem ) {
return siblings( ( elem.parentNode || {} ).firstChild, elem );
},
children: function( elem ) {
return siblings( elem.firstChild );
},
contents: function( elem ) {
if ( elem.contentDocument != null &&
3440
	// Support: IE 11+
	// <object> elements with no `data` attribute has an object
	// `contentDocument` with a `null` prototype.
	getProto( elem.contentDocument ) ) {
3445
	return elem.contentDocument;
}
3448
// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
// Treat the template element as a regular one in browsers that
// don't support it.
if ( nodeName( elem, "template" ) ) {
	elem = elem.content || elem;
}
3455
return jQuery.merge( [], elem.childNodes );
}
3458}, function( name, fn ) {
jQuery.fn[ name ] = function( until, selector ) {
var matched = jQuery.map( this, fn, until );
3461
if ( name.slice( -5 ) !== "Until" ) {
	selector = until;
}
3465
if ( selector && typeof selector === "string" ) {
	matched = jQuery.filter( selector, matched );
}
3469
if ( this.length > 1 ) {
3471
	// Remove duplicates
	if ( !guaranteedUnique[ name ] ) {
		jQuery.uniqueSort( matched );
	}
3476
	// Reverse order for parents* and prev-derivatives
	if ( rparentsprev.test( name ) ) {
		matched.reverse();
	}
}
3482
return this.pushStack( matched );
};
3485} );
3486var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
3487
3488
3489
3490// Convert String-formatted options into Object-formatted ones
3491function createOptions( options ) {
var object = {};
jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
object[ flag ] = true;
} );
return object;
3497}
3498
3499/*
* Create a callback list using the following parameters:
*
*	options: an optional list of space-separated options that will change how
*			the callback list behaves or a more traditional option object
*
* By default a callback list will act like an event callback list and can be
* "fired" multiple times.
*
* Possible options:
*
*	once:			will ensure the callback list can only be fired once (like a Deferred)
*
*	memory:			will keep track of previous values and will call any callback added
*					after the list has been fired right away with the latest "memorized"
*					values (like a Deferred)
*
*	unique:			will ensure a callback can only be added once (no duplicate in the list)
*
*	stopOnFalse:	interrupt callings when a callback returns false
*
*/
3521jQuery.Callbacks = function( options ) {
3522
// Convert options from String-formatted to Object-formatted if needed
// (we check in cache first)
options = typeof options === "string" ?
createOptions( options ) :
jQuery.extend( {}, options );
3528
var // Flag to know if list is currently firing
firing,
3531
// Last fire value for non-forgettable lists
memory,
3534
// Flag to know if list was already fired
fired,
3537
// Flag to prevent firing
locked,
3540
// Actual callback list
list = [],
3543
// Queue of execution data for repeatable lists
queue = [],
3546
// Index of currently firing callback (modified by add/remove as needed)
firingIndex = -1,
3549
// Fire callbacks
fire = function() {
3552
	// Enforce single-firing
	locked = locked || options.once;
3555
	// Execute callbacks for all pending executions,
	// respecting firingIndex overrides and runtime changes
	fired = firing = true;
	for ( ; queue.length; firingIndex = -1 ) {
		memory = queue.shift();
		while ( ++firingIndex < list.length ) {
3562
			// Run callback and check for early termination
			if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
				options.stopOnFalse ) {
3566
				// Jump to end and forget the data so .add doesn't re-fire
				firingIndex = list.length;
				memory = false;
			}
		}
	}
3573
	// Forget the data if we're done with it
	if ( !options.memory ) {
		memory = false;
	}
3578
	firing = false;
3580
	// Clean up if we're done firing for good
	if ( locked ) {
3583
		// Keep an empty list if we have data for future add calls
		if ( memory ) {
			list = [];
3587
		// Otherwise, this object is spent
		} else {
			list = "";
		}
	}
},
3594
// Actual Callbacks object
self = {
3597
	// Add a callback or a collection of callbacks to the list
	add: function() {
		if ( list ) {
3601
			// If we have memory from a past run, we should fire after adding
			if ( memory && !firing ) {
				firingIndex = list.length - 1;
				queue.push( memory );
			}
3607
			( function add( args ) {
				jQuery.each( args, function( _, arg ) {
					if ( isFunction( arg ) ) {
						if ( !options.unique || !self.has( arg ) ) {
							list.push( arg );
						}
					} else if ( arg && arg.length && toType( arg ) !== "string" ) {
3615
						// Inspect recursively
						add( arg );
					}
				} );
			} )( arguments );
3621
			if ( memory && !firing ) {
				fire();
			}
		}
		return this;
	},
3628
	// Remove a callback from the list
	remove: function() {
		jQuery.each( arguments, function( _, arg ) {
			var index;
			while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
				list.splice( index, 1 );
3635
				// Handle firing indexes
				if ( index <= firingIndex ) {
					firingIndex--;
				}
			}
		} );
		return this;
	},
3644
	// Check if a given callback is in the list.
	// If no argument is given, return whether or not list has callbacks attached.
	has: function( fn ) {
		return fn ?
			jQuery.inArray( fn, list ) > -1 :
			list.length > 0;
	},
3652
	// Remove all callbacks from the list
	empty: function() {
		if ( list ) {
			list = [];
		}
		return this;
	},
3660
	// Disable .fire and .add
	// Abort any current/pending executions
	// Clear all callbacks and values
	disable: function() {
		locked = queue = [];
		list = memory = "";
		return this;
	},
	disabled: function() {
		return !list;
	},
3672
	// Disable .fire
	// Also disable .add unless we have memory (since it would have no effect)
	// Abort any pending executions
	lock: function() {
		locked = queue = [];
		if ( !memory && !firing ) {
			list = memory = "";
		}
		return this;
	},
	locked: function() {
		return !!locked;
	},
3686
	// Call all callbacks with the given context and arguments
	fireWith: function( context, args ) {
		if ( !locked ) {
			args = args || [];
			args = [ context, args.slice ? args.slice() : args ];
			queue.push( args );
			if ( !firing ) {
				fire();
			}
		}
		return this;
	},
3699
	// Call all the callbacks with the given arguments
	fire: function() {
		self.fireWith( this, arguments );
		return this;
	},
3705
	// To know if the callbacks have already been called at least once
	fired: function() {
		return !!fired;
	}
};
3711
return self;
3713};
3714
3715
3716function Identity( v ) {
return v;
3718}
3719function Thrower( ex ) {
throw ex;
3721}
3722
3723function adoptValue( value, resolve, reject, noValue ) {
var method;
3725
try {
3727
// Check for promise aspect first to privilege synchronous behavior
if ( value && isFunction( ( method = value.promise ) ) ) {
	method.call( value ).done( resolve ).fail( reject );
3731
// Other thenables
} else if ( value && isFunction( ( method = value.then ) ) ) {
	method.call( value, resolve, reject );
3735
// Other non-thenables
} else {
3738
	// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
	// * false: [ value ].slice( 0 ) => resolve( value )
	// * true: [ value ].slice( 1 ) => resolve()
	resolve.apply( undefined, [ value ].slice( noValue ) );
}
3744
// For Promises/A+, convert exceptions into rejections
// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
// Deferred#then to conditionally suppress rejection.
} catch ( value ) {
3749
// Support: Android 4.0 only
// Strict mode functions invoked without .call/.apply get global-object context
reject.apply( undefined, [ value ] );
}
3754}
3755
3756jQuery.extend( {
3757
Deferred: function( func ) {
var tuples = [
3760
		// action, add listener, callbacks,
		// ... .then handlers, argument index, [final state]
		[ "notify", "progress", jQuery.Callbacks( "memory" ),
			jQuery.Callbacks( "memory" ), 2 ],
		[ "resolve", "done", jQuery.Callbacks( "once memory" ),
			jQuery.Callbacks( "once memory" ), 0, "resolved" ],
		[ "reject", "fail", jQuery.Callbacks( "once memory" ),
			jQuery.Callbacks( "once memory" ), 1, "rejected" ]
	],
	state = "pending",
	promise = {
		state: function() {
			return state;
		},
		always: function() {
			deferred.done( arguments ).fail( arguments );
			return this;
		},
		"catch": function( fn ) {
			return promise.then( null, fn );
		},
3782
		// Keep pipe for back-compat
		pipe: function( /* fnDone, fnFail, fnProgress */ ) {
			var fns = arguments;
3786
			return jQuery.Deferred( function( newDefer ) {
				jQuery.each( tuples, function( _i, tuple ) {
3789
					// Map tuples (progress, done, fail) to arguments (done, fail, progress)
					var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
3792
					// deferred.progress(function() { bind to newDefer or newDefer.notify })
					// deferred.done(function() { bind to newDefer or newDefer.resolve })
					// deferred.fail(function() { bind to newDefer or newDefer.reject })
					deferred[ tuple[ 1 ] ]( function() {
						var returned = fn && fn.apply( this, arguments );
						if ( returned && isFunction( returned.promise ) ) {
							returned.promise()
								.progress( newDefer.notify )
								.done( newDefer.resolve )
								.fail( newDefer.reject );
						} else {
							newDefer[ tuple[ 0 ] + "With" ](
								this,
								fn ? [ returned ] : arguments
							);
						}
					} );
				} );
				fns = null;
			} ).promise();
		},
		then: function( onFulfilled, onRejected, onProgress ) {
			var maxDepth = 0;
			function resolve( depth, deferred, handler, special ) {
				return function() {
					var that = this,
						args = arguments,
						mightThrow = function() {
							var returned, then;
3822
							// Support: Promises/A+ section 2.3.3.3.3
							// https://promisesaplus.com/#point-59
							// Ignore double-resolution attempts
							if ( depth < maxDepth ) {
								return;
							}
3829
							returned = handler.apply( that, args );
3831
							// Support: Promises/A+ section 2.3.1
							// https://promisesaplus.com/#point-48
							if ( returned === deferred.promise() ) {
								throw new TypeError( "Thenable self-resolution" );
							}
3837
							// Support: Promises/A+ sections 2.3.3.1, 3.5
							// https://promisesaplus.com/#point-54
							// https://promisesaplus.com/#point-75
							// Retrieve `then` only once
							then = returned &&
3843
								// Support: Promises/A+ section 2.3.4
								// https://promisesaplus.com/#point-64
								// Only check objects and functions for thenability
								( typeof returned === "object" ||
									typeof returned === "function" ) &&
								returned.then;
3850
							// Handle a returned thenable
							if ( isFunction( then ) ) {
3853
								// Special processors (notify) just wait for resolution
								if ( special ) {
									then.call(
										returned,
										resolve( maxDepth, deferred, Identity, special ),
										resolve( maxDepth, deferred, Thrower, special )
									);
3861
								// Normal processors (resolve) also hook into progress
								} else {
3864
									// ...and disregard older resolution values
									maxDepth++;
3867
									then.call(
										returned,
										resolve( maxDepth, deferred, Identity, special ),
										resolve( maxDepth, deferred, Thrower, special ),
										resolve( maxDepth, deferred, Identity,
											deferred.notifyWith )
									);
								}
3876
							// Handle all other returned values
							} else {
3879
								// Only substitute handlers pass on context
								// and multiple values (non-spec behavior)
								if ( handler !== Identity ) {
									that = undefined;
									args = [ returned ];
								}
3886
								// Process the value(s)
								// Default process is resolve
								( special || deferred.resolveWith )( that, args );
							}
						},
3892
						// Only normal processors (resolve) catch and reject exceptions
						process = special ?
							mightThrow :
							function() {
								try {
									mightThrow();
								} catch ( e ) {
3900
									if ( jQuery.Deferred.exceptionHook ) {
										jQuery.Deferred.exceptionHook( e,
											process.stackTrace );
									}
3905
									// Support: Promises/A+ section 2.3.3.3.4.1
									// https://promisesaplus.com/#point-61
									// Ignore post-resolution exceptions
									if ( depth + 1 >= maxDepth ) {
3910
										// Only substitute handlers pass on context
										// and multiple values (non-spec behavior)
										if ( handler !== Thrower ) {
											that = undefined;
											args = [ e ];
										}
3917
										deferred.rejectWith( that, args );
									}
								}
							};
3922
					// Support: Promises/A+ section 2.3.3.3.1
					// https://promisesaplus.com/#point-57
					// Re-resolve promises immediately to dodge false rejection from
					// subsequent errors
					if ( depth ) {
						process();
					} else {
3930
						// Call an optional hook to record the stack, in case of exception
						// since it's otherwise lost when execution goes async
						if ( jQuery.Deferred.getStackHook ) {
							process.stackTrace = jQuery.Deferred.getStackHook();
						}
						window.setTimeout( process );
					}
				};
			}
3940
			return jQuery.Deferred( function( newDefer ) {
3942
				// progress_handlers.add( ... )
				tuples[ 0 ][ 3 ].add(
					resolve(
						0,
						newDefer,
						isFunction( onProgress ) ?
							onProgress :
							Identity,
						newDefer.notifyWith
					)
				);
3954
				// fulfilled_handlers.add( ... )
				tuples[ 1 ][ 3 ].add(
					resolve(
						0,
						newDefer,
						isFunction( onFulfilled ) ?
							onFulfilled :
							Identity
					)
				);
3965
				// rejected_handlers.add( ... )
				tuples[ 2 ][ 3 ].add(
					resolve(
						0,
						newDefer,
						isFunction( onRejected ) ?
							onRejected :
							Thrower
					)
				);
			} ).promise();
		},
3978
		// Get a promise for this deferred
		// If obj is provided, the promise aspect is added to the object
		promise: function( obj ) {
			return obj != null ? jQuery.extend( obj, promise ) : promise;
		}
	},
	deferred = {};
3986
// Add list-specific methods
jQuery.each( tuples, function( i, tuple ) {
	var list = tuple[ 2 ],
		stateString = tuple[ 5 ];
3991
	// promise.progress = list.add
	// promise.done = list.add
	// promise.fail = list.add
	promise[ tuple[ 1 ] ] = list.add;
3996
	// Handle state
	if ( stateString ) {
		list.add(
			function() {
4001
				// state = "resolved" (i.e., fulfilled)
				// state = "rejected"
				state = stateString;
			},
4006
			// rejected_callbacks.disable
			// fulfilled_callbacks.disable
			tuples[ 3 - i ][ 2 ].disable,
4010
			// rejected_handlers.disable
			// fulfilled_handlers.disable
			tuples[ 3 - i ][ 3 ].disable,
4014
			// progress_callbacks.lock
			tuples[ 0 ][ 2 ].lock,
4017
			// progress_handlers.lock
			tuples[ 0 ][ 3 ].lock
		);
	}
4022
	// progress_handlers.fire
	// fulfilled_handlers.fire
	// rejected_handlers.fire
	list.add( tuple[ 3 ].fire );
4027
	// deferred.notify = function() { deferred.notifyWith(...) }
	// deferred.resolve = function() { deferred.resolveWith(...) }
	// deferred.reject = function() { deferred.rejectWith(...) }
	deferred[ tuple[ 0 ] ] = function() {
		deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
		return this;
	};
4035
	// deferred.notifyWith = list.fireWith
	// deferred.resolveWith = list.fireWith
	// deferred.rejectWith = list.fireWith
	deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
} );
4041
// Make the deferred a promise
promise.promise( deferred );
4044
// Call given func if any
if ( func ) {
	func.call( deferred, deferred );
}
4049
// All done!
return deferred;
},
4053
// Deferred helper
when: function( singleValue ) {
var
4057
	// count of uncompleted subordinates
	remaining = arguments.length,
4060
	// count of unprocessed arguments
	i = remaining,
4063
	// subordinate fulfillment data
	resolveContexts = Array( i ),
	resolveValues = slice.call( arguments ),
4067
	// the primary Deferred
	primary = jQuery.Deferred(),
4070
	// subordinate callback factory
	updateFunc = function( i ) {
		return function( value ) {
			resolveContexts[ i ] = this;
			resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
			if ( !( --remaining ) ) {
				primary.resolveWith( resolveContexts, resolveValues );
			}
		};
	};
4081
// Single- and empty arguments are adopted like Promise.resolve
if ( remaining <= 1 ) {
	adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,
		!remaining );
4086
	// Use .then() to unwrap secondary thenables (cf. gh-3000)
	if ( primary.state() === "pending" ||
		isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
4090
		return primary.then();
	}
}
4094
// Multiple arguments are aggregated like Promise.all array elements
while ( i-- ) {
	adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );
}
4099
return primary.promise();
}
4102} );
4103
4104
4105// These usually indicate a programmer mistake during development,
4106// warn about them ASAP rather than swallowing them by default.
4107var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
4108
4109jQuery.Deferred.exceptionHook = function( error, stack ) {
4110
// Support: IE 8 - 9 only
// Console exists when dev tools are open, which can happen at any time
if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
}
4116};
4117
4118
4119
4120
4121jQuery.readyException = function( error ) {
window.setTimeout( function() {
throw error;
} );
4125};
4126
4127
4128
4129
4130// The deferred used on DOM ready
4131var readyList = jQuery.Deferred();
4132
4133jQuery.fn.ready = function( fn ) {
4134
readyList
.then( fn )
4137
// Wrap jQuery.readyException in a function so that the lookup
// happens at the time of error handling instead of callback
// registration.
.catch( function( error ) {
	jQuery.readyException( error );
} );
4144
return this;
4146};
4147
4148jQuery.extend( {
4149
// Is the DOM ready to be used? Set to true once it occurs.
isReady: false,
4152
// A counter to track how many items to wait for before
// the ready event fires. See trac-6781
readyWait: 1,
4156
// Handle when the DOM is ready
ready: function( wait ) {
4159
// Abort if there are pending holds or we're already ready
if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
	return;
}
4164
// Remember that the DOM is ready
jQuery.isReady = true;
4167
// If a normal DOM Ready event fired, decrement, and wait if need be
if ( wait !== true && --jQuery.readyWait > 0 ) {
	return;
}
4172
// If there are functions bound, to execute
readyList.resolveWith( document, [ jQuery ] );
}
4176} );
4177
4178jQuery.ready.then = readyList.then;
4179
4180// The ready event handler and self cleanup method
4181function completed() {
document.removeEventListener( "DOMContentLoaded", completed );
window.removeEventListener( "load", completed );
jQuery.ready();
4185}
4186
4187// Catch cases where $(document).ready() is called
4188// after the browser event has already occurred.
4189// Support: IE <=9 - 10 only
4190// Older IE sometimes signals "interactive" too soon
4191if ( document.readyState === "complete" ||
( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
4193
// Handle it asynchronously to allow scripts the opportunity to delay ready
window.setTimeout( jQuery.ready );
4196
4197} else {
4198
// Use the handy event callback
document.addEventListener( "DOMContentLoaded", completed );
4201
// A fallback to window.onload, that will always work
window.addEventListener( "load", completed );
4204}
4205
4206
4207
4208
4209// Multifunctional method to get and set values of a collection
4210// The value/s can optionally be executed if it's a function
4211var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
var i = 0,
len = elems.length,
bulk = key == null;
4215
// Sets many values
if ( toType( key ) === "object" ) {
chainable = true;
for ( i in key ) {
	access( elems, fn, i, key[ i ], true, emptyGet, raw );
}
4222
// Sets one value
} else if ( value !== undefined ) {
chainable = true;
4226
if ( !isFunction( value ) ) {
	raw = true;
}
4230
if ( bulk ) {
4232
	// Bulk operations run against the entire set
	if ( raw ) {
		fn.call( elems, value );
		fn = null;
4237
	// ...except when executing function values
	} else {
		bulk = fn;
		fn = function( elem, _key, value ) {
			return bulk.call( jQuery( elem ), value );
		};
	}
}
4246
if ( fn ) {
	for ( ; i < len; i++ ) {
		fn(
			elems[ i ], key, raw ?
				value :
				value.call( elems[ i ], i, fn( elems[ i ], key ) )
		);
	}
}
}
4257
if ( chainable ) {
return elems;
}
4261
// Gets
if ( bulk ) {
return fn.call( elems );
}
4266
return len ? fn( elems[ 0 ], key ) : emptyGet;
4268};
4269
4270
4271// Matches dashed string for camelizing
4272var rmsPrefix = /^-ms-/,
rdashAlpha = /-([a-z])/g;
4274
4275// Used by camelCase as callback to replace()
4276function fcamelCase( _all, letter ) {
return letter.toUpperCase();
4278}
4279
4280// Convert dashed to camelCase; used by the css and data modules
4281// Support: IE <=9 - 11, Edge 12 - 15
4282// Microsoft forgot to hump their vendor prefix (trac-9572)
4283function camelCase( string ) {
return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
4285}
4286var acceptData = function( owner ) {
4287
// Accepts only:
//  - Node
//    - Node.ELEMENT_NODE
//    - Node.DOCUMENT_NODE
//  - Object
//    - Any
return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
4295};
4296
4297
4298
4299
4300function Data() {
this.expando = jQuery.expando + Data.uid++;
4302}
4303
4304Data.uid = 1;
4305
4306Data.prototype = {
4307
cache: function( owner ) {
4309
// Check if the owner object already has a cache
var value = owner[ this.expando ];
4312
// If not, create one
if ( !value ) {
	value = {};
4316
	// We can accept data for non-element nodes in modern browsers,
	// but we should not, see trac-8335.
	// Always return an empty object.
	if ( acceptData( owner ) ) {
4321
		// If it is a node unlikely to be stringify-ed or looped over
		// use plain assignment
		if ( owner.nodeType ) {
			owner[ this.expando ] = value;
4326
		// Otherwise secure it in a non-enumerable property
		// configurable must be true to allow the property to be
		// deleted when data is removed
		} else {
			Object.defineProperty( owner, this.expando, {
				value: value,
				configurable: true
			} );
		}
	}
}
4338
return value;
},
set: function( owner, data, value ) {
var prop,
	cache = this.cache( owner );
4344
// Handle: [ owner, key, value ] args
// Always use camelCase key (gh-2257)
if ( typeof data === "string" ) {
	cache[ camelCase( data ) ] = value;
4349
// Handle: [ owner, { properties } ] args
} else {
4352
	// Copy the properties one-by-one to the cache object
	for ( prop in data ) {
		cache[ camelCase( prop ) ] = data[ prop ];
	}
}
return cache;
},
get: function( owner, key ) {
return key === undefined ?
	this.cache( owner ) :
4363
	// Always use camelCase key (gh-2257)
	owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];
},
access: function( owner, key, value ) {
4368
// In cases where either:
//
//   1. No key was specified
//   2. A string key was specified, but no value provided
//
// Take the "read" path and allow the get method to determine
// which value to return, respectively either:
//
//   1. The entire cache object
//   2. The data stored at the key
//
if ( key === undefined ||
		( ( key && typeof key === "string" ) && value === undefined ) ) {
4382
	return this.get( owner, key );
}
4385
// When the key is not a string, or both a key and value
// are specified, set or extend (existing objects) with either:
//
//   1. An object of properties
//   2. A key and value
//
this.set( owner, key, value );
4393
// Since the "set" path can have two possible entry points
// return the expected data based on which path was taken[*]
return value !== undefined ? value : key;
},
remove: function( owner, key ) {
var i,
	cache = owner[ this.expando ];
4401
if ( cache === undefined ) {
	return;
}
4405
if ( key !== undefined ) {
4407
	// Support array or space separated string of keys
	if ( Array.isArray( key ) ) {
4410
		// If key is an array of keys...
		// We always set camelCase keys, so remove that.
		key = key.map( camelCase );
	} else {
		key = camelCase( key );
4416
		// If a key with the spaces exists, use it.
		// Otherwise, create an array by matching non-whitespace
		key = key in cache ?
			[ key ] :
			( key.match( rnothtmlwhite ) || [] );
	}
4423
	i = key.length;
4425
	while ( i-- ) {
		delete cache[ key[ i ] ];
	}
}
4430
// Remove the expando if there's no more data
if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
4433
	// Support: Chrome <=35 - 45
	// Webkit & Blink performance suffers when deleting properties
	// from DOM nodes, so set to undefined instead
	// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
	if ( owner.nodeType ) {
		owner[ this.expando ] = undefined;
	} else {
		delete owner[ this.expando ];
	}
}
},
hasData: function( owner ) {
var cache = owner[ this.expando ];
return cache !== undefined && !jQuery.isEmptyObject( cache );
}
4449};
4450var dataPriv = new Data();
4451
4452var dataUser = new Data();
4453
4454
4455
4456//	Implementation Summary
4457//
4458//	1. Enforce API surface and semantic compatibility with 1.9.x branch
4459//	2. Improve the module's maintainability by reducing the storage
4460//		paths to a single mechanism.
4461//	3. Use the same single mechanism to support "private" and "user" data.
4462//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
4463//	5. Avoid exposing implementation details on user objects (eg. expando properties)
4464//	6. Provide a clear path for implementation upgrade to WeakMap in 2014
4465
4466var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
rmultiDash = /[A-Z]/g;
4468
4469function getData( data ) {
if ( data === "true" ) {
return true;
}
4473
if ( data === "false" ) {
return false;
}
4477
if ( data === "null" ) {
return null;
}
4481
// Only convert to a number if it doesn't change the string
if ( data === +data + "" ) {
return +data;
}
4486
if ( rbrace.test( data ) ) {
return JSON.parse( data );
}
4490
return data;
4492}
4493
4494function dataAttr( elem, key, data ) {
var name;
4496
// If nothing was found internally, try to fetch any
// data from the HTML5 data-* attribute
if ( data === undefined && elem.nodeType === 1 ) {
name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
data = elem.getAttribute( name );
4502
if ( typeof data === "string" ) {
	try {
		data = getData( data );
	} catch ( e ) {}
4507
	// Make sure we set the data so it isn't changed later
	dataUser.set( elem, key, data );
} else {
	data = undefined;
}
}
return data;
4515}
4516
4517jQuery.extend( {
hasData: function( elem ) {
return dataUser.hasData( elem ) || dataPriv.hasData( elem );
},
4521
data: function( elem, name, data ) {
return dataUser.access( elem, name, data );
},
4525
removeData: function( elem, name ) {
dataUser.remove( elem, name );
},
4529
// TODO: Now that all calls to _data and _removeData have been replaced
// with direct calls to dataPriv methods, these can be deprecated.
_data: function( elem, name, data ) {
return dataPriv.access( elem, name, data );
},
4535
_removeData: function( elem, name ) {
dataPriv.remove( elem, name );
}
4539} );
4540
4541jQuery.fn.extend( {
data: function( key, value ) {
var i, name, data,
	elem = this[ 0 ],
	attrs = elem && elem.attributes;
4546
// Gets all values
if ( key === undefined ) {
	if ( this.length ) {
		data = dataUser.get( elem );
4551
		if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
			i = attrs.length;
			while ( i-- ) {
4555
				// Support: IE 11 only
				// The attrs elements can be null (trac-14894)
				if ( attrs[ i ] ) {
					name = attrs[ i ].name;
					if ( name.indexOf( "data-" ) === 0 ) {
						name = camelCase( name.slice( 5 ) );
						dataAttr( elem, name, data[ name ] );
					}
				}
			}
			dataPriv.set( elem, "hasDataAttrs", true );
		}
	}
4569
	return data;
}
4572
// Sets multiple values
if ( typeof key === "object" ) {
	return this.each( function() {
		dataUser.set( this, key );
	} );
}
4579
return access( this, function( value ) {
	var data;
4582
	// The calling jQuery object (element matches) is not empty
	// (and therefore has an element appears at this[ 0 ]) and the
	// `value` parameter was not undefined. An empty jQuery object
	// will result in `undefined` for elem = this[ 0 ] which will
	// throw an exception if an attempt to read a data cache is made.
	if ( elem && value === undefined ) {
4589
		// Attempt to get data from the cache
		// The key will always be camelCased in Data
		data = dataUser.get( elem, key );
		if ( data !== undefined ) {
			return data;
		}
4596
		// Attempt to "discover" the data in
		// HTML5 custom data-* attrs
		data = dataAttr( elem, key );
		if ( data !== undefined ) {
			return data;
		}
4603
		// We tried really hard, but the data doesn't exist.
		return;
	}
4607
	// Set the data...
	this.each( function() {
4610
		// We always store the camelCased key
		dataUser.set( this, key, value );
	} );
}, null, value, arguments.length > 1, null, true );
},
4616
removeData: function( key ) {
return this.each( function() {
	dataUser.remove( this, key );
} );
}
4622} );
4623
4624
4625jQuery.extend( {
queue: function( elem, type, data ) {
var queue;
4628
if ( elem ) {
	type = ( type || "fx" ) + "queue";
	queue = dataPriv.get( elem, type );
4632
	// Speed up dequeue by getting out quickly if this is just a lookup
	if ( data ) {
		if ( !queue || Array.isArray( data ) ) {
			queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
		} else {
			queue.push( data );
		}
	}
	return queue || [];
}
},
4644
dequeue: function( elem, type ) {
type = type || "fx";
4647
var queue = jQuery.queue( elem, type ),
	startLength = queue.length,
	fn = queue.shift(),
	hooks = jQuery._queueHooks( elem, type ),
	next = function() {
		jQuery.dequeue( elem, type );
	};
4655
// If the fx queue is dequeued, always remove the progress sentinel
if ( fn === "inprogress" ) {
	fn = queue.shift();
	startLength--;
}
4661
if ( fn ) {
4663
	// Add a progress sentinel to prevent the fx queue from being
	// automatically dequeued
	if ( type === "fx" ) {
		queue.unshift( "inprogress" );
	}
4669
	// Clear up the last queue stop function
	delete hooks.stop;
	fn.call( elem, next, hooks );
}
4674
if ( !startLength && hooks ) {
	hooks.empty.fire();
}
},
4679
// Not public - generate a queueHooks object, or return the current one
_queueHooks: function( elem, type ) {
var key = type + "queueHooks";
return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
	empty: jQuery.Callbacks( "once memory" ).add( function() {
		dataPriv.remove( elem, [ type + "queue", key ] );
	} )
} );
}
4689} );
4690
4691jQuery.fn.extend( {
queue: function( type, data ) {
var setter = 2;
4694
if ( typeof type !== "string" ) {
	data = type;
	type = "fx";
	setter--;
}
4700
if ( arguments.length < setter ) {
	return jQuery.queue( this[ 0 ], type );
}
4704
return data === undefined ?
	this :
	this.each( function() {
		var queue = jQuery.queue( this, type, data );
4709
		// Ensure a hooks for this queue
		jQuery._queueHooks( this, type );
4712
		if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
			jQuery.dequeue( this, type );
		}
	} );
},
dequeue: function( type ) {
return this.each( function() {
	jQuery.dequeue( this, type );
} );
},
clearQueue: function( type ) {
return this.queue( type || "fx", [] );
},
4726
// Get a promise resolved when queues of a certain type
// are emptied (fx is the type by default)
promise: function( type, obj ) {
var tmp,
	count = 1,
	defer = jQuery.Deferred(),
	elements = this,
	i = this.length,
	resolve = function() {
		if ( !( --count ) ) {
			defer.resolveWith( elements, [ elements ] );
		}
	};
4740
if ( typeof type !== "string" ) {
	obj = type;
	type = undefined;
}
type = type || "fx";
4746
while ( i-- ) {
	tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
	if ( tmp && tmp.empty ) {
		count++;
		tmp.empty.add( resolve );
	}
}
resolve();
return defer.promise( obj );
}
4757} );
4758var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
4759
4760var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
4761
4762
4763var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
4764
4765var documentElement = document.documentElement;
4766
4767
4768
var isAttached = function( elem ) {
	return jQuery.contains( elem.ownerDocument, elem );
},
composed = { composed: true };
4773
// Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only
// Check attachment across shadow DOM boundaries when possible (gh-3504)
// Support: iOS 10.0-10.2 only
// Early iOS 10 versions support `attachShadow` but not `getRootNode`,
// leading to errors. We need to check for `getRootNode`.
if ( documentElement.getRootNode ) {
isAttached = function( elem ) {
	return jQuery.contains( elem.ownerDocument, elem ) ||
		elem.getRootNode( composed ) === elem.ownerDocument;
};
}
4785var isHiddenWithinTree = function( elem, el ) {
4786
// isHiddenWithinTree might be called from jQuery#filter function;
// in that case, element will be second argument
elem = el || elem;
4790
// Inline style trumps all
return elem.style.display === "none" ||
	elem.style.display === "" &&
4794
	// Otherwise, check computed style
	// Support: Firefox <=43 - 45
	// Disconnected elements can have computed display: none, so first confirm that elem is
	// in the document.
	isAttached( elem ) &&
4800
	jQuery.css( elem, "display" ) === "none";
};
4803
4804
4805
4806function adjustCSS( elem, prop, valueParts, tween ) {
var adjusted, scale,
maxIterations = 20,
currentValue = tween ?
	function() {
		return tween.cur();
	} :
	function() {
		return jQuery.css( elem, prop, "" );
	},
initial = currentValue(),
unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
4818
// Starting value computation is required for potential unit mismatches
initialInUnit = elem.nodeType &&
	( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
	rcssNum.exec( jQuery.css( elem, prop ) );
4823
if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
4825
// Support: Firefox <=54
// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
initial = initial / 2;
4829
// Trust units reported by jQuery.css
unit = unit || initialInUnit[ 3 ];
4832
// Iteratively approximate from a nonzero starting point
initialInUnit = +initial || 1;
4835
while ( maxIterations-- ) {
4837
	// Evaluate and update our best guess (doubling guesses that zero out).
	// Finish if the scale equals or crosses 1 (making the old*new product non-positive).
	jQuery.style( elem, prop, initialInUnit + unit );
	if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {
		maxIterations = 0;
	}
	initialInUnit = initialInUnit / scale;
4845
}
4847
initialInUnit = initialInUnit * 2;
jQuery.style( elem, prop, initialInUnit + unit );
4850
// Make sure we update the tween properties later on
valueParts = valueParts || [];
}
4854
if ( valueParts ) {
initialInUnit = +initialInUnit || +initial || 0;
4857
// Apply relative offset (+=/-=) if specified
adjusted = valueParts[ 1 ] ?
	initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
	+valueParts[ 2 ];
if ( tween ) {
	tween.unit = unit;
	tween.start = initialInUnit;
	tween.end = adjusted;
}
}
return adjusted;
4869}
4870
4871
4872var defaultDisplayMap = {};
4873
4874function getDefaultDisplay( elem ) {
var temp,
doc = elem.ownerDocument,
nodeName = elem.nodeName,
display = defaultDisplayMap[ nodeName ];
4879
if ( display ) {
return display;
}
4883
temp = doc.body.appendChild( doc.createElement( nodeName ) );
display = jQuery.css( temp, "display" );
4886
temp.parentNode.removeChild( temp );
4888
if ( display === "none" ) {
display = "block";
}
defaultDisplayMap[ nodeName ] = display;
4893
return display;
4895}
4896
4897function showHide( elements, show ) {
var display, elem,
values = [],
index = 0,
length = elements.length;
4902
// Determine new display value for elements that need to change
for ( ; index < length; index++ ) {
elem = elements[ index ];
if ( !elem.style ) {
	continue;
}
4909
display = elem.style.display;
if ( show ) {
4912
	// Since we force visibility upon cascade-hidden elements, an immediate (and slow)
	// check is required in this first loop unless we have a nonempty display value (either
	// inline or about-to-be-restored)
	if ( display === "none" ) {
		values[ index ] = dataPriv.get( elem, "display" ) || null;
		if ( !values[ index ] ) {
			elem.style.display = "";
		}
	}
	if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
		values[ index ] = getDefaultDisplay( elem );
	}
} else {
	if ( display !== "none" ) {
		values[ index ] = "none";
4928
		// Remember what we're overwriting
		dataPriv.set( elem, "display", display );
	}
}
}
4934
// Set the display of the elements in a second loop to avoid constant reflow
for ( index = 0; index < length; index++ ) {
if ( values[ index ] != null ) {
	elements[ index ].style.display = values[ index ];
}
}
4941
return elements;
4943}
4944
4945jQuery.fn.extend( {
show: function() {
return showHide( this, true );
},
hide: function() {
return showHide( this );
},
toggle: function( state ) {
if ( typeof state === "boolean" ) {
	return state ? this.show() : this.hide();
}
4956
return this.each( function() {
	if ( isHiddenWithinTree( this ) ) {
		jQuery( this ).show();
	} else {
		jQuery( this ).hide();
	}
} );
}
4965} );
4966var rcheckableType = ( /^(?:checkbox|radio)$/i );
4967
4968var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i );
4969
4970var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i );
4971
4972
4973
4974( function() {
var fragment = document.createDocumentFragment(),
div = fragment.appendChild( document.createElement( "div" ) ),
input = document.createElement( "input" );
4978
// Support: Android 4.0 - 4.3 only
// Check state lost if the name is set (trac-11217)
// Support: Windows Web Apps (WWA)
// `name` and `type` must use .setAttribute for WWA (trac-14901)
input.setAttribute( "type", "radio" );
input.setAttribute( "checked", "checked" );
input.setAttribute( "name", "t" );
4986
div.appendChild( input );
4988
// Support: Android <=4.1 only
// Older WebKit doesn't clone checked state correctly in fragments
support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
4992
// Support: IE <=11 only
// Make sure textarea (and checkbox) defaultValue is properly cloned
div.innerHTML = "<textarea>x</textarea>";
support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
4997
// Support: IE <=9 only
// IE <=9 replaces <option> tags with their contents when inserted outside of
// the select element.
div.innerHTML = "<option></option>";
support.option = !!div.lastChild;
5003} )();
5004
5005
5006// We have to close these tags to support XHTML (trac-13200)
5007var wrapMap = {
5008
// XHTML parsers do not magically insert elements in the
// same way that tag soup parsers do. So we cannot shorten
// this by omitting <tbody> or other required elements.
thead: [ 1, "<table>", "</table>" ],
col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
tr: [ 2, "<table><tbody>", "</tbody></table>" ],
td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
5016
_default: [ 0, "", "" ]
5018};
5019
5020wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
5021wrapMap.th = wrapMap.td;
5022
5023// Support: IE <=9 only
5024if ( !support.option ) {
wrapMap.optgroup = wrapMap.option = [ 1, "<select multiple='multiple'>", "</select>" ];
5026}
5027
5028
5029function getAll( context, tag ) {
5030
// Support: IE <=9 - 11 only
// Use typeof to avoid zero-argument method invocation on host objects (trac-15151)
var ret;
5034
if ( typeof context.getElementsByTagName !== "undefined" ) {
ret = context.getElementsByTagName( tag || "*" );
5037
} else if ( typeof context.querySelectorAll !== "undefined" ) {
ret = context.querySelectorAll( tag || "*" );
5040
} else {
ret = [];
}
5044
if ( tag === undefined || tag && nodeName( context, tag ) ) {
return jQuery.merge( [ context ], ret );
}
5048
return ret;
5050}
5051
5052
5053// Mark scripts as having already been evaluated
5054function setGlobalEval( elems, refElements ) {
var i = 0,
l = elems.length;
5057
for ( ; i < l; i++ ) {
dataPriv.set(
	elems[ i ],
	"globalEval",
	!refElements || dataPriv.get( refElements[ i ], "globalEval" )
);
}
5065}
5066
5067
5068var rhtml = /<|&#?\w+;/;
5069
5070function buildFragment( elems, context, scripts, selection, ignored ) {
var elem, tmp, tag, wrap, attached, j,
fragment = context.createDocumentFragment(),
nodes = [],
i = 0,
l = elems.length;
5076
for ( ; i < l; i++ ) {
elem = elems[ i ];
5079
if ( elem || elem === 0 ) {
5081
	// Add nodes directly
	if ( toType( elem ) === "object" ) {
5084
		// Support: Android <=4.0 only, PhantomJS 1 only
		// push.apply(_, arraylike) throws on ancient WebKit
		jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
5088
	// Convert non-html into a text node
	} else if ( !rhtml.test( elem ) ) {
		nodes.push( context.createTextNode( elem ) );
5092
	// Convert html into DOM nodes
	} else {
		tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
5096
		// Deserialize a standard representation
		tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
		wrap = wrapMap[ tag ] || wrapMap._default;
		tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
5101
		// Descend through wrappers to the right content
		j = wrap[ 0 ];
		while ( j-- ) {
			tmp = tmp.lastChild;
		}
5107
		// Support: Android <=4.0 only, PhantomJS 1 only
		// push.apply(_, arraylike) throws on ancient WebKit
		jQuery.merge( nodes, tmp.childNodes );
5111
		// Remember the top-level container
		tmp = fragment.firstChild;
5114
		// Ensure the created nodes are orphaned (trac-12392)
		tmp.textContent = "";
	}
}
}
5120
// Remove wrapper from fragment
fragment.textContent = "";
5123
i = 0;
while ( ( elem = nodes[ i++ ] ) ) {
5126
// Skip elements already in the context collection (trac-4087)
if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
	if ( ignored ) {
		ignored.push( elem );
	}
	continue;
}
5134
attached = isAttached( elem );
5136
// Append to fragment
tmp = getAll( fragment.appendChild( elem ), "script" );
5139
// Preserve script evaluation history
if ( attached ) {
	setGlobalEval( tmp );
}
5144
// Capture executables
if ( scripts ) {
	j = 0;
	while ( ( elem = tmp[ j++ ] ) ) {
		if ( rscriptType.test( elem.type || "" ) ) {
			scripts.push( elem );
		}
	}
}
}
5155
return fragment;
5157}
5158
5159
5160var rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
5161
5162function returnTrue() {
return true;
5164}
5165
5166function returnFalse() {
return false;
5168}
5169
5170// Support: IE <=9 - 11+
5171// focus() and blur() are asynchronous, except when they are no-op.
5172// So expect focus to be synchronous when the element is already active,
5173// and blur to be synchronous when the element is not already active.
5174// (focus and blur are always synchronous in other supported browsers,
5175// this just defines when we can count on it).
5176function expectSync( elem, type ) {
return ( elem === safeActiveElement() ) === ( type === "focus" );
5178}
5179
5180// Support: IE <=9 only
5181// Accessing document.activeElement can throw unexpectedly
5182// https://bugs.jquery.com/ticket/13393
5183function safeActiveElement() {
try {
return document.activeElement;
} catch ( err ) { }
5187}
5188
5189function on( elem, types, selector, data, fn, one ) {
var origFn, type;
5191
// Types can be a map of types/handlers
if ( typeof types === "object" ) {
5194
// ( types-Object, selector, data )
if ( typeof selector !== "string" ) {
5197
	// ( types-Object, data )
	data = data || selector;
	selector = undefined;
}
for ( type in types ) {
	on( elem, type, selector, data, types[ type ], one );
}
return elem;
}
5207
if ( data == null && fn == null ) {
5209
// ( types, fn )
fn = selector;
data = selector = undefined;
} else if ( fn == null ) {
if ( typeof selector === "string" ) {
5215
	// ( types, selector, fn )
	fn = data;
	data = undefined;
} else {
5220
	// ( types, data, fn )
	fn = data;
	data = selector;
	selector = undefined;
}
}
if ( fn === false ) {
fn = returnFalse;
} else if ( !fn ) {
return elem;
}
5232
if ( one === 1 ) {
origFn = fn;
fn = function( event ) {
5236
	// Can use an empty set, since event contains the info
	jQuery().off( event );
	return origFn.apply( this, arguments );
};
5241
// Use same guid so caller can remove using origFn
fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
}
return elem.each( function() {
jQuery.event.add( this, types, fn, data, selector );
} );
5248}
5249
5250/*
* Helper functions for managing events -- not part of the public interface.
* Props to Dean Edwards' addEvent library for many of the ideas.
*/
5254jQuery.event = {
5255
global: {},
5257
add: function( elem, types, handler, data, selector ) {
5259
var handleObjIn, eventHandle, tmp,
	events, t, handleObj,
	special, handlers, type, namespaces, origType,
	elemData = dataPriv.get( elem );
5264
// Only attach events to objects that accept data
if ( !acceptData( elem ) ) {
	return;
}
5269
// Caller can pass in an object of custom data in lieu of the handler
if ( handler.handler ) {
	handleObjIn = handler;
	handler = handleObjIn.handler;
	selector = handleObjIn.selector;
}
5276
// Ensure that invalid selectors throw exceptions at attach time
// Evaluate against documentElement in case elem is a non-element node (e.g., document)
if ( selector ) {
	jQuery.find.matchesSelector( documentElement, selector );
}
5282
// Make sure that the handler has a unique ID, used to find/remove it later
if ( !handler.guid ) {
	handler.guid = jQuery.guid++;
}
5287
// Init the element's event structure and main handler, if this is the first
if ( !( events = elemData.events ) ) {
	events = elemData.events = Object.create( null );
}
if ( !( eventHandle = elemData.handle ) ) {
	eventHandle = elemData.handle = function( e ) {
5294
		// Discard the second event of a jQuery.event.trigger() and
		// when an event is called after a page has unloaded
		return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
			jQuery.event.dispatch.apply( elem, arguments ) : undefined;
	};
}
5301
// Handle multiple events separated by a space
types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
t = types.length;
while ( t-- ) {
	tmp = rtypenamespace.exec( types[ t ] ) || [];
	type = origType = tmp[ 1 ];
	namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
5309
	// There *must* be a type, no attaching namespace-only handlers
	if ( !type ) {
		continue;
	}
5314
	// If event changes its type, use the special event handlers for the changed type
	special = jQuery.event.special[ type ] || {};
5317
	// If selector defined, determine special event api type, otherwise given type
	type = ( selector ? special.delegateType : special.bindType ) || type;
5320
	// Update special based on newly reset type
	special = jQuery.event.special[ type ] || {};
5323
	// handleObj is passed to all event handlers
	handleObj = jQuery.extend( {
		type: type,
		origType: origType,
		data: data,
		handler: handler,
		guid: handler.guid,
		selector: selector,
		needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
		namespace: namespaces.join( "." )
	}, handleObjIn );
5335
	// Init the event handler queue if we're the first
	if ( !( handlers = events[ type ] ) ) {
		handlers = events[ type ] = [];
		handlers.delegateCount = 0;
5340
		// Only use addEventListener if the special events handler returns false
		if ( !special.setup ||
			special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
5344
			if ( elem.addEventListener ) {
				elem.addEventListener( type, eventHandle );
			}
		}
	}
5350
	if ( special.add ) {
		special.add.call( elem, handleObj );
5353
		if ( !handleObj.handler.guid ) {
			handleObj.handler.guid = handler.guid;
		}
	}
5358
	// Add to the element's handler list, delegates in front
	if ( selector ) {
		handlers.splice( handlers.delegateCount++, 0, handleObj );
	} else {
		handlers.push( handleObj );
	}
5365
	// Keep track of which events have ever been used, for event optimization
	jQuery.event.global[ type ] = true;
}
5369
},
5371
// Detach an event or set of events from an element
remove: function( elem, types, handler, selector, mappedTypes ) {
5374
var j, origCount, tmp,
	events, t, handleObj,
	special, handlers, type, namespaces, origType,
	elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
5379
if ( !elemData || !( events = elemData.events ) ) {
	return;
}
5383
// Once for each type.namespace in types; type may be omitted
types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
t = types.length;
while ( t-- ) {
	tmp = rtypenamespace.exec( types[ t ] ) || [];
	type = origType = tmp[ 1 ];
	namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
5391
	// Unbind all events (on this namespace, if provided) for the element
	if ( !type ) {
		for ( type in events ) {
			jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
		}
		continue;
	}
5399
	special = jQuery.event.special[ type ] || {};
	type = ( selector ? special.delegateType : special.bindType ) || type;
	handlers = events[ type ] || [];
	tmp = tmp[ 2 ] &&
		new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
5405
	// Remove matching events
	origCount = j = handlers.length;
	while ( j-- ) {
		handleObj = handlers[ j ];
5410
		if ( ( mappedTypes || origType === handleObj.origType ) &&
			( !handler || handler.guid === handleObj.guid ) &&
			( !tmp || tmp.test( handleObj.namespace ) ) &&
			( !selector || selector === handleObj.selector ||
				selector === "**" && handleObj.selector ) ) {
			handlers.splice( j, 1 );
5417
			if ( handleObj.selector ) {
				handlers.delegateCount--;
			}
			if ( special.remove ) {
				special.remove.call( elem, handleObj );
			}
		}
	}
5426
	// Remove generic event handler if we removed something and no more handlers exist
	// (avoids potential for endless recursion during removal of special event handlers)
	if ( origCount && !handlers.length ) {
		if ( !special.teardown ||
			special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
5432
			jQuery.removeEvent( elem, type, elemData.handle );
		}
5435
		delete events[ type ];
	}
}
5439
// Remove data and the expando if it's no longer used
if ( jQuery.isEmptyObject( events ) ) {
	dataPriv.remove( elem, "handle events" );
}
},
5445
dispatch: function( nativeEvent ) {
5447
var i, j, ret, matched, handleObj, handlerQueue,
	args = new Array( arguments.length ),
5450
	// Make a writable jQuery.Event from the native event object
	event = jQuery.event.fix( nativeEvent ),
5453
	handlers = (
		dataPriv.get( this, "events" ) || Object.create( null )
	)[ event.type ] || [],
	special = jQuery.event.special[ event.type ] || {};
5458
// Use the fix-ed jQuery.Event rather than the (read-only) native event
args[ 0 ] = event;
5461
for ( i = 1; i < arguments.length; i++ ) {
	args[ i ] = arguments[ i ];
}
5465
event.delegateTarget = this;
5467
// Call the preDispatch hook for the mapped type, and let it bail if desired
if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
	return;
}
5472
// Determine handlers
handlerQueue = jQuery.event.handlers.call( this, event, handlers );
5475
// Run delegates first; they may want to stop propagation beneath us
i = 0;
while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
	event.currentTarget = matched.elem;
5480
	j = 0;
	while ( ( handleObj = matched.handlers[ j++ ] ) &&
		!event.isImmediatePropagationStopped() ) {
5484
		// If the event is namespaced, then each handler is only invoked if it is
		// specially universal or its namespaces are a superset of the event's.
		if ( !event.rnamespace || handleObj.namespace === false ||
			event.rnamespace.test( handleObj.namespace ) ) {
5489
			event.handleObj = handleObj;
			event.data = handleObj.data;
5492
			ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
				handleObj.handler ).apply( matched.elem, args );
5495
			if ( ret !== undefined ) {
				if ( ( event.result = ret ) === false ) {
					event.preventDefault();
					event.stopPropagation();
				}
			}
		}
	}
}
5505
// Call the postDispatch hook for the mapped type
if ( special.postDispatch ) {
	special.postDispatch.call( this, event );
}
5510
return event.result;
},
5513
handlers: function( event, handlers ) {
var i, handleObj, sel, matchedHandlers, matchedSelectors,
	handlerQueue = [],
	delegateCount = handlers.delegateCount,
	cur = event.target;
5519
// Find delegate handlers
if ( delegateCount &&
5522
	// Support: IE <=9
	// Black-hole SVG <use> instance trees (trac-13180)
	cur.nodeType &&
5526
	// Support: Firefox <=42
	// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
	// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
	// Support: IE 11 only
	// ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
	!( event.type === "click" && event.button >= 1 ) ) {
5533
	for ( ; cur !== this; cur = cur.parentNode || this ) {
5535
		// Don't check non-elements (trac-13208)
		// Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764)
		if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
			matchedHandlers = [];
			matchedSelectors = {};
			for ( i = 0; i < delegateCount; i++ ) {
				handleObj = handlers[ i ];
5543
				// Don't conflict with Object.prototype properties (trac-13203)
				sel = handleObj.selector + " ";
5546
				if ( matchedSelectors[ sel ] === undefined ) {
					matchedSelectors[ sel ] = handleObj.needsContext ?
						jQuery( sel, this ).index( cur ) > -1 :
						jQuery.find( sel, this, null, [ cur ] ).length;
				}
				if ( matchedSelectors[ sel ] ) {
					matchedHandlers.push( handleObj );
				}
			}
			if ( matchedHandlers.length ) {
				handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
			}
		}
	}
}
5562
// Add the remaining (directly-bound) handlers
cur = this;
if ( delegateCount < handlers.length ) {
	handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
}
5568
return handlerQueue;
},
5571
addProp: function( name, hook ) {
Object.defineProperty( jQuery.Event.prototype, name, {
	enumerable: true,
	configurable: true,
5576
	get: isFunction( hook ) ?
		function() {
			if ( this.originalEvent ) {
				return hook( this.originalEvent );
			}
		} :
		function() {
			if ( this.originalEvent ) {
				return this.originalEvent[ name ];
			}
		},
5588
	set: function( value ) {
		Object.defineProperty( this, name, {
			enumerable: true,
			configurable: true,
			writable: true,
			value: value
		} );
	}
} );
},
5599
fix: function( originalEvent ) {
return originalEvent[ jQuery.expando ] ?
	originalEvent :
	new jQuery.Event( originalEvent );
},
5605
special: {
load: {
5608
	// Prevent triggered image.load events from bubbling to window.load
	noBubble: true
},
click: {
5613
	// Utilize native event to ensure correct state for checkable inputs
	setup: function( data ) {
5616
		// For mutual compressibility with _default, replace `this` access with a local var.
		// `|| data` is dead code meant only to preserve the variable through minification.
		var el = this || data;
5620
		// Claim the first handler
		if ( rcheckableType.test( el.type ) &&
			el.click && nodeName( el, "input" ) ) {
5624
			// dataPriv.set( el, "click", ... )
			leverageNative( el, "click", returnTrue );
		}
5628
		// Return false to allow normal processing in the caller
		return false;
	},
	trigger: function( data ) {
5633
		// For mutual compressibility with _default, replace `this` access with a local var.
		// `|| data` is dead code meant only to preserve the variable through minification.
		var el = this || data;
5637
		// Force setup before triggering a click
		if ( rcheckableType.test( el.type ) &&
			el.click && nodeName( el, "input" ) ) {
5641
			leverageNative( el, "click" );
		}
5644
		// Return non-false to allow normal event-path propagation
		return true;
	},
5648
	// For cross-browser consistency, suppress native .click() on links
	// Also prevent it if we're currently inside a leveraged native-event stack
	_default: function( event ) {
		var target = event.target;
		return rcheckableType.test( target.type ) &&
			target.click && nodeName( target, "input" ) &&
			dataPriv.get( target, "click" ) ||
			nodeName( target, "a" );
	}
},
5659
beforeunload: {
	postDispatch: function( event ) {
5662
		// Support: Firefox 20+
		// Firefox doesn't alert if the returnValue field is not set.
		if ( event.result !== undefined && event.originalEvent ) {
			event.originalEvent.returnValue = event.result;
		}
	}
}
}
5671};
5672
5673// Ensure the presence of an event listener that handles manually-triggered
5674// synthetic events by interrupting progress until reinvoked in response to
5675// *native* events that it fires directly, ensuring that state changes have
5676// already occurred before other listeners are invoked.
5677function leverageNative( el, type, expectSync ) {
5678
// Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add
if ( !expectSync ) {
if ( dataPriv.get( el, type ) === undefined ) {
	jQuery.event.add( el, type, returnTrue );
}
return;
}
5686
// Register the controller as a special universal handler for all event namespaces
dataPriv.set( el, type, false );
jQuery.event.add( el, type, {
namespace: false,
handler: function( event ) {
	var notAsync, result,
		saved = dataPriv.get( this, type );
5694
	if ( ( event.isTrigger & 1 ) && this[ type ] ) {
5696
		// Interrupt processing of the outer synthetic .trigger()ed event
		// Saved data should be false in such cases, but might be a leftover capture object
		// from an async native handler (gh-4350)
		if ( !saved.length ) {
5701
			// Store arguments for use when handling the inner native event
			// There will always be at least one argument (an event object), so this array
			// will not be confused with a leftover capture object.
			saved = slice.call( arguments );
			dataPriv.set( this, type, saved );
5707
			// Trigger the native event and capture its result
			// Support: IE <=9 - 11+
			// focus() and blur() are asynchronous
			notAsync = expectSync( this, type );
			this[ type ]();
			result = dataPriv.get( this, type );
			if ( saved !== result || notAsync ) {
				dataPriv.set( this, type, false );
			} else {
				result = {};
			}
			if ( saved !== result ) {
5720
				// Cancel the outer synthetic event
				event.stopImmediatePropagation();
				event.preventDefault();
5724
				// Support: Chrome 86+
				// In Chrome, if an element having a focusout handler is blurred by
				// clicking outside of it, it invokes the handler synchronously. If
				// that handler calls `.remove()` on the element, the data is cleared,
				// leaving `result` undefined. We need to guard against this.
				return result && result.value;
			}
5732
		// If this is an inner synthetic event for an event with a bubbling surrogate
		// (focus or blur), assume that the surrogate already propagated from triggering the
		// native event and prevent that from happening again here.
		// This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the
		// bubbling surrogate propagates *after* the non-bubbling base), but that seems
		// less bad than duplication.
		} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {
			event.stopPropagation();
		}
5742
	// If this is a native event triggered above, everything is now in order
	// Fire an inner synthetic event with the original arguments
	} else if ( saved.length ) {
5746
		// ...and capture the result
		dataPriv.set( this, type, {
			value: jQuery.event.trigger(
5750
				// Support: IE <=9 - 11+
				// Extend with the prototype to reset the above stopImmediatePropagation()
				jQuery.extend( saved[ 0 ], jQuery.Event.prototype ),
				saved.slice( 1 ),
				this
			)
		} );
5758
		// Abort handling of the native event
		event.stopImmediatePropagation();
	}
}
} );
5764}
5765
5766jQuery.removeEvent = function( elem, type, handle ) {
5767
// This "if" is needed for plain objects
if ( elem.removeEventListener ) {
elem.removeEventListener( type, handle );
}
5772};
5773
5774jQuery.Event = function( src, props ) {
5775
// Allow instantiation without the 'new' keyword
if ( !( this instanceof jQuery.Event ) ) {
return new jQuery.Event( src, props );
}
5780
// Event object
if ( src && src.type ) {
this.originalEvent = src;
this.type = src.type;
5785
// Events bubbling up the document may have been marked as prevented
// by a handler lower down the tree; reflect the correct value.
this.isDefaultPrevented = src.defaultPrevented ||
		src.defaultPrevented === undefined &&
5790
		// Support: Android <=2.3 only
		src.returnValue === false ?
	returnTrue :
	returnFalse;
5795
// Create target properties
// Support: Safari <=6 - 7 only
// Target should not be a text node (trac-504, trac-13143)
this.target = ( src.target && src.target.nodeType === 3 ) ?
	src.target.parentNode :
	src.target;
5802
this.currentTarget = src.currentTarget;
this.relatedTarget = src.relatedTarget;
5805
// Event type
} else {
this.type = src;
}
5810
// Put explicitly provided properties onto the event object
if ( props ) {
jQuery.extend( this, props );
}
5815
// Create a timestamp if incoming event doesn't have one
this.timeStamp = src && src.timeStamp || Date.now();
5818
// Mark it as fixed
this[ jQuery.expando ] = true;
5821};
5822
5823// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
5824// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
5825jQuery.Event.prototype = {
constructor: jQuery.Event,
isDefaultPrevented: returnFalse,
isPropagationStopped: returnFalse,
isImmediatePropagationStopped: returnFalse,
isSimulated: false,
5831
preventDefault: function() {
var e = this.originalEvent;
5834
this.isDefaultPrevented = returnTrue;
5836
if ( e && !this.isSimulated ) {
	e.preventDefault();
}
},
stopPropagation: function() {
var e = this.originalEvent;
5843
this.isPropagationStopped = returnTrue;
5845
if ( e && !this.isSimulated ) {
	e.stopPropagation();
}
},
stopImmediatePropagation: function() {
var e = this.originalEvent;
5852
this.isImmediatePropagationStopped = returnTrue;
5854
if ( e && !this.isSimulated ) {
	e.stopImmediatePropagation();
}
5858
this.stopPropagation();
}
5861};
5862
5863// Includes all common event props including KeyEvent and MouseEvent specific props
5864jQuery.each( {
altKey: true,
bubbles: true,
cancelable: true,
changedTouches: true,
ctrlKey: true,
detail: true,
eventPhase: true,
metaKey: true,
pageX: true,
pageY: true,
shiftKey: true,
view: true,
"char": true,
code: true,
charCode: true,
key: true,
keyCode: true,
button: true,
buttons: true,
clientX: true,
clientY: true,
offsetX: true,
offsetY: true,
pointerId: true,
pointerType: true,
screenX: true,
screenY: true,
targetTouches: true,
toElement: true,
touches: true,
which: true
5896}, jQuery.event.addProp );
5897
5898jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) {
jQuery.event.special[ type ] = {
5900
// Utilize native event if possible so blur/focus sequence is correct
setup: function() {
5903
	// Claim the first handler
	// dataPriv.set( this, "focus", ... )
	// dataPriv.set( this, "blur", ... )
	leverageNative( this, type, expectSync );
5908
	// Return false to allow normal processing in the caller
	return false;
},
trigger: function() {
5913
	// Force setup before trigger
	leverageNative( this, type );
5916
	// Return non-false to allow normal event-path propagation
	return true;
},
5920
// Suppress native focus or blur if we're currently inside
// a leveraged native-event stack
_default: function( event ) {
	return dataPriv.get( event.target, type );
},
5926
delegateType: delegateType
};
5929} );
5930
5931// Create mouseenter/leave events using mouseover/out and event-time checks
5932// so that event delegation works in jQuery.
5933// Do the same for pointerenter/pointerleave and pointerover/pointerout
5934//
5935// Support: Safari 7 only
5936// Safari sends mouseenter too often; see:
5937// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
5938// for the description of the bug (it existed in older Chrome versions as well).
5939jQuery.each( {
mouseenter: "mouseover",
mouseleave: "mouseout",
pointerenter: "pointerover",
pointerleave: "pointerout"
5944}, function( orig, fix ) {
jQuery.event.special[ orig ] = {
delegateType: fix,
bindType: fix,
5948
handle: function( event ) {
	var ret,
		target = this,
		related = event.relatedTarget,
		handleObj = event.handleObj;
5954
	// For mouseenter/leave call the handler if related is outside the target.
	// NB: No relatedTarget if the mouse left/entered the browser window
	if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
		event.type = handleObj.origType;
		ret = handleObj.handler.apply( this, arguments );
		event.type = fix;
	}
	return ret;
}
};
5965} );
5966
5967jQuery.fn.extend( {
5968
on: function( types, selector, data, fn ) {
return on( this, types, selector, data, fn );
},
one: function( types, selector, data, fn ) {
return on( this, types, selector, data, fn, 1 );
},
off: function( types, selector, fn ) {
var handleObj, type;
if ( types && types.preventDefault && types.handleObj ) {
5978
	// ( event )  dispatched jQuery.Event
	handleObj = types.handleObj;
	jQuery( types.delegateTarget ).off(
		handleObj.namespace ?
			handleObj.origType + "." + handleObj.namespace :
			handleObj.origType,
		handleObj.selector,
		handleObj.handler
	);
	return this;
}
if ( typeof types === "object" ) {
5991
	// ( types-object [, selector] )
	for ( type in types ) {
		this.off( type, selector, types[ type ] );
	}
	return this;
}
if ( selector === false || typeof selector === "function" ) {
5999
	// ( types [, fn] )
	fn = selector;
	selector = undefined;
}
if ( fn === false ) {
	fn = returnFalse;
}
return this.each( function() {
	jQuery.event.remove( this, types, fn, selector );
} );
}
6011} );
6012
6013
6014var
6015
// Support: IE <=10 - 11, Edge 12 - 13 only
// In IE/Edge using regex groups here causes severe slowdowns.
// See https://connect.microsoft.com/IE/feedback/details/1736512/
rnoInnerhtml = /<script|<style|<link/i,
6020
// checked="checked" or checked
rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
6023
rcleanScript = /^\s*<!\[CDATA\[|\]\]>\s*$/g;
6025
6026// Prefer a tbody over its parent table for containing new rows
6027function manipulationTarget( elem, content ) {
if ( nodeName( elem, "table" ) &&
nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
6030
return jQuery( elem ).children( "tbody" )[ 0 ] || elem;
}
6033
return elem;
6035}
6036
6037// Replace/restore the type attribute of script elements for safe DOM manipulation
6038function disableScript( elem ) {
elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
return elem;
6041}
6042function restoreScript( elem ) {
if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) {
elem.type = elem.type.slice( 5 );
} else {
elem.removeAttribute( "type" );
}
6048
return elem;
6050}
6051
6052function cloneCopyEvent( src, dest ) {
var i, l, type, pdataOld, udataOld, udataCur, events;
6054
if ( dest.nodeType !== 1 ) {
return;
}
6058
// 1. Copy private data: events, handlers, etc.
if ( dataPriv.hasData( src ) ) {
pdataOld = dataPriv.get( src );
events = pdataOld.events;
6063
if ( events ) {
	dataPriv.remove( dest, "handle events" );
6066
	for ( type in events ) {
		for ( i = 0, l = events[ type ].length; i < l; i++ ) {
			jQuery.event.add( dest, type, events[ type ][ i ] );
		}
	}
}
}
6074
// 2. Copy user data
if ( dataUser.hasData( src ) ) {
udataOld = dataUser.access( src );
udataCur = jQuery.extend( {}, udataOld );
6079
dataUser.set( dest, udataCur );
}
6082}
6083
6084// Fix IE bugs, see support tests
6085function fixInput( src, dest ) {
var nodeName = dest.nodeName.toLowerCase();
6087
// Fails to persist the checked state of a cloned checkbox or radio button.
if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
dest.checked = src.checked;
6091
// Fails to return the selected option to the default selected state when cloning options
} else if ( nodeName === "input" || nodeName === "textarea" ) {
dest.defaultValue = src.defaultValue;
}
6096}
6097
6098function domManip( collection, args, callback, ignored ) {
6099
// Flatten any nested arrays
args = flat( args );
6102
var fragment, first, scripts, hasScripts, node, doc,
i = 0,
l = collection.length,
iNoClone = l - 1,
value = args[ 0 ],
valueIsFunction = isFunction( value );
6109
// We can't cloneNode fragments that contain checked, in WebKit
if ( valueIsFunction ||
	( l > 1 && typeof value === "string" &&
		!support.checkClone && rchecked.test( value ) ) ) {
return collection.each( function( index ) {
	var self = collection.eq( index );
	if ( valueIsFunction ) {
		args[ 0 ] = value.call( this, index, self.html() );
	}
	domManip( self, args, callback, ignored );
} );
}
6122
if ( l ) {
fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
first = fragment.firstChild;
6126
if ( fragment.childNodes.length === 1 ) {
	fragment = first;
}
6130
// Require either new content or an interest in ignored elements to invoke the callback
if ( first || ignored ) {
	scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
	hasScripts = scripts.length;
6135
	// Use the original fragment for the last item
	// instead of the first because it can end up
	// being emptied incorrectly in certain situations (trac-8070).
	for ( ; i < l; i++ ) {
		node = fragment;
6141
		if ( i !== iNoClone ) {
			node = jQuery.clone( node, true, true );
6144
			// Keep references to cloned scripts for later restoration
			if ( hasScripts ) {
6147
				// Support: Android <=4.0 only, PhantomJS 1 only
				// push.apply(_, arraylike) throws on ancient WebKit
				jQuery.merge( scripts, getAll( node, "script" ) );
			}
		}
6153
		callback.call( collection[ i ], node, i );
	}
6156
	if ( hasScripts ) {
		doc = scripts[ scripts.length - 1 ].ownerDocument;
6159
		// Reenable scripts
		jQuery.map( scripts, restoreScript );
6162
		// Evaluate executable scripts on first document insertion
		for ( i = 0; i < hasScripts; i++ ) {
			node = scripts[ i ];
			if ( rscriptType.test( node.type || "" ) &&
				!dataPriv.access( node, "globalEval" ) &&
				jQuery.contains( doc, node ) ) {
6169
				if ( node.src && ( node.type || "" ).toLowerCase()  !== "module" ) {
6171
					// Optional AJAX dependency, but won't run scripts if not present
					if ( jQuery._evalUrl && !node.noModule ) {
						jQuery._evalUrl( node.src, {
							nonce: node.nonce || node.getAttribute( "nonce" )
						}, doc );
					}
				} else {
6179
					// Unwrap a CDATA section containing script contents. This shouldn't be
					// needed as in XML documents they're already not visible when
					// inspecting element contents and in HTML documents they have no
					// meaning but we're preserving that logic for backwards compatibility.
					// This will be removed completely in 4.0. See gh-4904.
					DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc );
				}
			}
		}
	}
}
}
6192
return collection;
6194}
6195
6196function remove( elem, selector, keepData ) {
var node,
nodes = selector ? jQuery.filter( selector, elem ) : elem,
i = 0;
6200
for ( ; ( node = nodes[ i ] ) != null; i++ ) {
if ( !keepData && node.nodeType === 1 ) {
	jQuery.cleanData( getAll( node ) );
}
6205
if ( node.parentNode ) {
	if ( keepData && isAttached( node ) ) {
		setGlobalEval( getAll( node, "script" ) );
	}
	node.parentNode.removeChild( node );
}
}
6213
return elem;
6215}
6216
6217jQuery.extend( {
htmlPrefilter: function( html ) {
return html;
},
6221
clone: function( elem, dataAndEvents, deepDataAndEvents ) {
var i, l, srcElements, destElements,
	clone = elem.cloneNode( true ),
	inPage = isAttached( elem );
6226
// Fix IE cloning issues
if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
		!jQuery.isXMLDoc( elem ) ) {
6230
	// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
	destElements = getAll( clone );
	srcElements = getAll( elem );
6234
	for ( i = 0, l = srcElements.length; i < l; i++ ) {
		fixInput( srcElements[ i ], destElements[ i ] );
	}
}
6239
// Copy the events from the original to the clone
if ( dataAndEvents ) {
	if ( deepDataAndEvents ) {
		srcElements = srcElements || getAll( elem );
		destElements = destElements || getAll( clone );
6245
		for ( i = 0, l = srcElements.length; i < l; i++ ) {
			cloneCopyEvent( srcElements[ i ], destElements[ i ] );
		}
	} else {
		cloneCopyEvent( elem, clone );
	}
}
6253
// Preserve script evaluation history
destElements = getAll( clone, "script" );
if ( destElements.length > 0 ) {
	setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
}
6259
// Return the cloned set
return clone;
},
6263
cleanData: function( elems ) {
var data, elem, type,
	special = jQuery.event.special,
	i = 0;
6268
for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
	if ( acceptData( elem ) ) {
		if ( ( data = elem[ dataPriv.expando ] ) ) {
			if ( data.events ) {
				for ( type in data.events ) {
					if ( special[ type ] ) {
						jQuery.event.remove( elem, type );
6276
					// This is a shortcut to avoid jQuery.event.remove's overhead
					} else {
						jQuery.removeEvent( elem, type, data.handle );
					}
				}
			}
6283
			// Support: Chrome <=35 - 45+
			// Assign undefined instead of using delete, see Data#remove
			elem[ dataPriv.expando ] = undefined;
		}
		if ( elem[ dataUser.expando ] ) {
6289
			// Support: Chrome <=35 - 45+
			// Assign undefined instead of using delete, see Data#remove
			elem[ dataUser.expando ] = undefined;
		}
	}
}
}
6297} );
6298
6299jQuery.fn.extend( {
detach: function( selector ) {
return remove( this, selector, true );
},
6303
remove: function( selector ) {
return remove( this, selector );
},
6307
text: function( value ) {
return access( this, function( value ) {
	return value === undefined ?
		jQuery.text( this ) :
		this.empty().each( function() {
			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
				this.textContent = value;
			}
		} );
}, null, value, arguments.length );
},
6319
append: function() {
return domManip( this, arguments, function( elem ) {
	if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
		var target = manipulationTarget( this, elem );
		target.appendChild( elem );
	}
} );
},
6328
prepend: function() {
return domManip( this, arguments, function( elem ) {
	if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
		var target = manipulationTarget( this, elem );
		target.insertBefore( elem, target.firstChild );
	}
} );
},
6337
before: function() {
return domManip( this, arguments, function( elem ) {
	if ( this.parentNode ) {
		this.parentNode.insertBefore( elem, this );
	}
} );
},
6345
after: function() {
return domManip( this, arguments, function( elem ) {
	if ( this.parentNode ) {
		this.parentNode.insertBefore( elem, this.nextSibling );
	}
} );
},
6353
empty: function() {
var elem,
	i = 0;
6357
for ( ; ( elem = this[ i ] ) != null; i++ ) {
	if ( elem.nodeType === 1 ) {
6360
		// Prevent memory leaks
		jQuery.cleanData( getAll( elem, false ) );
6363
		// Remove any remaining nodes
		elem.textContent = "";
	}
}
6368
return this;
},
6371
clone: function( dataAndEvents, deepDataAndEvents ) {
dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
6375
return this.map( function() {
	return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
} );
},
6380
html: function( value ) {
return access( this, function( value ) {
	var elem = this[ 0 ] || {},
		i = 0,
		l = this.length;
6386
	if ( value === undefined && elem.nodeType === 1 ) {
		return elem.innerHTML;
	}
6390
	// See if we can take a shortcut and just use innerHTML
	if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
		!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
6394
		value = jQuery.htmlPrefilter( value );
6396
		try {
			for ( ; i < l; i++ ) {
				elem = this[ i ] || {};
6400
				// Remove element nodes and prevent memory leaks
				if ( elem.nodeType === 1 ) {
					jQuery.cleanData( getAll( elem, false ) );
					elem.innerHTML = value;
				}
			}
6407
			elem = 0;
6409
		// If using innerHTML throws an exception, use the fallback method
		} catch ( e ) {}
	}
6413
	if ( elem ) {
		this.empty().append( value );
	}
}, null, value, arguments.length );
},
6419
replaceWith: function() {
var ignored = [];
6422
// Make the changes, replacing each non-ignored context element with the new content
return domManip( this, arguments, function( elem ) {
	var parent = this.parentNode;
6426
	if ( jQuery.inArray( this, ignored ) < 0 ) {
		jQuery.cleanData( getAll( this ) );
		if ( parent ) {
			parent.replaceChild( elem, this );
		}
	}
6433
// Force callback invocation
}, ignored );
}
6437} );
6438
6439jQuery.each( {
appendTo: "append",
prependTo: "prepend",
insertBefore: "before",
insertAfter: "after",
replaceAll: "replaceWith"
6445}, function( name, original ) {
jQuery.fn[ name ] = function( selector ) {
var elems,
	ret = [],
	insert = jQuery( selector ),
	last = insert.length - 1,
	i = 0;
6452
for ( ; i <= last; i++ ) {
	elems = i === last ? this : this.clone( true );
	jQuery( insert[ i ] )[ original ]( elems );
6456
	// Support: Android <=4.0 only, PhantomJS 1 only
	// .get() because push.apply(_, arraylike) throws on ancient WebKit
	push.apply( ret, elems.get() );
}
6461
return this.pushStack( ret );
};
6464} );
6465var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
6466
6467var rcustomProp = /^--/;
6468
6469
6470var getStyles = function( elem ) {
6471
// Support: IE <=11 only, Firefox <=30 (trac-15098, trac-14150)
// IE throws on elements created in popups
// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
var view = elem.ownerDocument.defaultView;
6476
if ( !view || !view.opener ) {
	view = window;
}
6480
return view.getComputedStyle( elem );
};
6483
6484var swap = function( elem, options, callback ) {
var ret, name,
old = {};
6487
// Remember the old values, and insert the new ones
for ( name in options ) {
old[ name ] = elem.style[ name ];
elem.style[ name ] = options[ name ];
}
6493
ret = callback.call( elem );
6495
// Revert the old values
for ( name in options ) {
elem.style[ name ] = old[ name ];
}
6500
return ret;
6502};
6503
6504
6505var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );
6506
6507var whitespace = "[\\x20\\t\\r\\n\\f]";
6508
6509
6510var rtrimCSS = new RegExp(
"^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$",
"g"
6513);
6514
6515
6516
6517
6518( function() {
6519
// Executing both pixelPosition & boxSizingReliable tests require only one layout
// so they're executed at the same time to save the second computation.
function computeStyleTests() {
6523
// This is a singleton, we need to execute it only once
if ( !div ) {
	return;
}
6528
container.style.cssText = "position:absolute;left:-11111px;width:60px;" +
	"margin-top:1px;padding:0;border:0";
div.style.cssText =
	"position:relative;display:block;box-sizing:border-box;overflow:scroll;" +
	"margin:auto;border:1px;padding:1px;" +
	"width:60%;top:1%";
documentElement.appendChild( container ).appendChild( div );
6536
var divStyle = window.getComputedStyle( div );
pixelPositionVal = divStyle.top !== "1%";
6539
// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;
6542
// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
// Some styles come back with percentage values, even though they shouldn't
div.style.right = "60%";
pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;
6547
// Support: IE 9 - 11 only
// Detect misreporting of content dimensions for box-sizing:border-box elements
boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;
6551
// Support: IE 9 only
// Detect overflow:scroll screwiness (gh-3699)
// Support: Chrome <=64
// Don't get tricked when zoom affects offsetWidth (gh-4029)
div.style.position = "absolute";
scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;
6558
documentElement.removeChild( container );
6560
// Nullify the div so it wouldn't be stored in the memory and
// it will also be a sign that checks already performed
div = null;
}
6565
function roundPixelMeasures( measure ) {
return Math.round( parseFloat( measure ) );
}
6569
var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,
reliableTrDimensionsVal, reliableMarginLeftVal,
container = document.createElement( "div" ),
div = document.createElement( "div" );
6574
// Finish early in limited (non-browser) environments
if ( !div.style ) {
return;
}
6579
// Support: IE <=9 - 11 only
// Style of cloned element affects source element cloned (trac-8908)
div.style.backgroundClip = "content-box";
div.cloneNode( true ).style.backgroundClip = "";
support.clearCloneStyle = div.style.backgroundClip === "content-box";
6585
jQuery.extend( support, {
boxSizingReliable: function() {
	computeStyleTests();
	return boxSizingReliableVal;
},
pixelBoxStyles: function() {
	computeStyleTests();
	return pixelBoxStylesVal;
},
pixelPosition: function() {
	computeStyleTests();
	return pixelPositionVal;
},
reliableMarginLeft: function() {
	computeStyleTests();
	return reliableMarginLeftVal;
},
scrollboxSize: function() {
	computeStyleTests();
	return scrollboxSizeVal;
},
6607
// Support: IE 9 - 11+, Edge 15 - 18+
// IE/Edge misreport `getComputedStyle` of table rows with width/height
// set in CSS while `offset*` properties report correct values.
// Behavior in IE 9 is more subtle than in newer versions & it passes
// some versions of this test; make sure not to make it pass there!
//
// Support: Firefox 70+
// Only Firefox includes border widths
// in computed dimensions. (gh-4529)
reliableTrDimensions: function() {
	var table, tr, trChild, trStyle;
	if ( reliableTrDimensionsVal == null ) {
		table = document.createElement( "table" );
		tr = document.createElement( "tr" );
		trChild = document.createElement( "div" );
6623
		table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate";
		tr.style.cssText = "border:1px solid";
6626
		// Support: Chrome 86+
		// Height set through cssText does not get applied.
		// Computed height then comes back as 0.
		tr.style.height = "1px";
		trChild.style.height = "9px";
6632
		// Support: Android 8 Chrome 86+
		// In our bodyBackground.html iframe,
		// display for all div elements is set to "inline",
		// which causes a problem only in Android 8 Chrome 86.
		// Ensuring the div is display: block
		// gets around this issue.
		trChild.style.display = "block";
6640
		documentElement
			.appendChild( table )
			.appendChild( tr )
			.appendChild( trChild );
6645
		trStyle = window.getComputedStyle( tr );
		reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +
			parseInt( trStyle.borderTopWidth, 10 ) +
			parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;
6650
		documentElement.removeChild( table );
	}
	return reliableTrDimensionsVal;
}
} );
6656} )();
6657
6658
6659function curCSS( elem, name, computed ) {
var width, minWidth, maxWidth, ret,
isCustomProp = rcustomProp.test( name ),
6662
// Support: Firefox 51+
// Retrieving style before computed somehow
// fixes an issue with getting wrong values
// on detached elements
style = elem.style;
6668
computed = computed || getStyles( elem );
6670
// getPropertyValue is needed for:
//   .css('filter') (IE 9 only, trac-12537)
//   .css('--customProperty) (gh-3144)
if ( computed ) {
6675
// Support: IE <=9 - 11+
// IE only supports `"float"` in `getPropertyValue`; in computed styles
// it's only available as `"cssFloat"`. We no longer modify properties
// sent to `.css()` apart from camelCasing, so we need to check both.
// Normally, this would create difference in behavior: if
// `getPropertyValue` returns an empty string, the value returned
// by `.css()` would be `undefined`. This is usually the case for
// disconnected elements. However, in IE even disconnected elements
// with no styles return `"none"` for `getPropertyValue( "float" )`
ret = computed.getPropertyValue( name ) || computed[ name ];
6686
if ( isCustomProp && ret ) {
6688
	// Support: Firefox 105+, Chrome <=105+
	// Spec requires trimming whitespace for custom properties (gh-4926).
	// Firefox only trims leading whitespace. Chrome just collapses
	// both leading & trailing whitespace to a single space.
	//
	// Fall back to `undefined` if empty string returned.
	// This collapses a missing definition with property defined
	// and set to an empty string but there's no standard API
	// allowing us to differentiate them without a performance penalty
	// and returning `undefined` aligns with older jQuery.
	//
	// rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED
	// as whitespace while CSS does not, but this is not a problem
	// because CSS preprocessing replaces them with U+000A LINE FEED
	// (which *is* CSS whitespace)
	// https://www.w3.org/TR/css-syntax-3/#input-preprocessing
	ret = ret.replace( rtrimCSS, "$1" ) || undefined;
}
6707
if ( ret === "" && !isAttached( elem ) ) {
	ret = jQuery.style( elem, name );
}
6711
// A tribute to the "awesome hack by Dean Edwards"
// Android Browser returns percentage for some values,
// but width seems to be reliably pixels.
// This is against the CSSOM draft spec:
// https://drafts.csswg.org/cssom/#resolved-values
if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {
6718
	// Remember the original values
	width = style.width;
	minWidth = style.minWidth;
	maxWidth = style.maxWidth;
6723
	// Put in the new values to get a computed value out
	style.minWidth = style.maxWidth = style.width = ret;
	ret = computed.width;
6727
	// Revert the changed values
	style.width = width;
	style.minWidth = minWidth;
	style.maxWidth = maxWidth;
}
}
6734
return ret !== undefined ?
6736
// Support: IE <=9 - 11 only
// IE returns zIndex value as an integer.
ret + "" :
ret;
6741}
6742
6743
6744function addGetHookIf( conditionFn, hookFn ) {
6745
// Define the hook, we'll check on the first run if it's really needed.
return {
get: function() {
	if ( conditionFn() ) {
6750
		// Hook not needed (or it's not possible to use it due
		// to missing dependency), remove it.
		delete this.get;
		return;
	}
6756
	// Hook needed; redefine it so that the support test is not executed again.
	return ( this.get = hookFn ).apply( this, arguments );
}
};
6761}
6762
6763
6764var cssPrefixes = [ "Webkit", "Moz", "ms" ],
emptyStyle = document.createElement( "div" ).style,
vendorProps = {};
6767
6768// Return a vendor-prefixed property or undefined
6769function vendorPropName( name ) {
6770
// Check for vendor prefixed names
var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
i = cssPrefixes.length;
6774
while ( i-- ) {
name = cssPrefixes[ i ] + capName;
if ( name in emptyStyle ) {
	return name;
}
}
6781}
6782
6783// Return a potentially-mapped jQuery.cssProps or vendor prefixed property
6784function finalPropName( name ) {
var final = jQuery.cssProps[ name ] || vendorProps[ name ];
6786
if ( final ) {
return final;
}
if ( name in emptyStyle ) {
return name;
}
return vendorProps[ name ] = vendorPropName( name ) || name;
6794}
6795
6796
6797var
6798
// Swappable if display is none or starts with table
// except "table", "table-cell", or "table-caption"
// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
rdisplayswap = /^(none|table(?!-c[ea]).+)/,
cssShow = { position: "absolute", visibility: "hidden", display: "block" },
cssNormalTransform = {
letterSpacing: "0",
fontWeight: "400"
};
6808
6809function setPositiveNumber( _elem, value, subtract ) {
6810
// Any relative (+/-) values have already been
// normalized at this point
var matches = rcssNum.exec( value );
return matches ?
6815
// Guard against undefined "subtract", e.g., when used as in cssHooks
Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
value;
6819}
6820
6821function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
var i = dimension === "width" ? 1 : 0,
extra = 0,
delta = 0;
6825
// Adjustment may not be necessary
if ( box === ( isBorderBox ? "border" : "content" ) ) {
return 0;
}
6830
for ( ; i < 4; i += 2 ) {
6832
// Both box models exclude margin
if ( box === "margin" ) {
	delta += jQuery.css( elem, box + cssExpand[ i ], true, styles );
}
6837
// If we get here with a content-box, we're seeking "padding" or "border" or "margin"
if ( !isBorderBox ) {
6840
	// Add padding
	delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6843
	// For "border" or "margin", add border
	if ( box !== "padding" ) {
		delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6847
	// But still keep track of it otherwise
	} else {
		extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
	}
6852
// If we get here with a border-box (content + padding + border), we're seeking "content" or
// "padding" or "margin"
} else {
6856
	// For "content", subtract padding
	if ( box === "content" ) {
		delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
	}
6861
	// For "content" or "padding", subtract border
	if ( box !== "margin" ) {
		delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
	}
}
}
6868
// Account for positive content-box scroll gutter when requested by providing computedVal
if ( !isBorderBox && computedVal >= 0 ) {
6871
// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
// Assuming integer scroll gutter, subtract the rest and round down
delta += Math.max( 0, Math.ceil(
	elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
	computedVal -
	delta -
	extra -
	0.5
6880
// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter
// Use an explicit zero to avoid NaN (gh-3964)
) ) || 0;
}
6885
return delta;
6887}
6888
6889function getWidthOrHeight( elem, dimension, extra ) {
6890
// Start with computed style
var styles = getStyles( elem ),
6893
// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).
// Fake content-box until we know it's needed to know the true value.
boxSizingNeeded = !support.boxSizingReliable() || extra,
isBorderBox = boxSizingNeeded &&
	jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
valueIsBorderBox = isBorderBox,
6900
val = curCSS( elem, dimension, styles ),
offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );
6903
// Support: Firefox <=54
// Return a confounding non-pixel value or feign ignorance, as appropriate.
if ( rnumnonpx.test( val ) ) {
if ( !extra ) {
	return val;
}
val = "auto";
}
6912
6913
// Support: IE 9 - 11 only
// Use offsetWidth/offsetHeight for when box sizing is unreliable.
// In those cases, the computed value can be trusted to be border-box.
if ( ( !support.boxSizingReliable() && isBorderBox ||
6918
// Support: IE 10 - 11+, Edge 15 - 18+
// IE/Edge misreport `getComputedStyle` of table rows with width/height
// set in CSS while `offset*` properties report correct values.
// Interestingly, in some cases IE 9 doesn't suffer from this issue.
!support.reliableTrDimensions() && nodeName( elem, "tr" ) ||
6924
// Fall back to offsetWidth/offsetHeight when value is "auto"
// This happens for inline elements with no explicit setting (gh-3571)
val === "auto" ||
6928
// Support: Android <=4.1 - 4.3 only
// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
!parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) &&
6932
// Make sure the element is visible & connected
elem.getClientRects().length ) {
6935
isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
6937
// Where available, offsetWidth/offsetHeight approximate border box dimensions.
// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the
// retrieved value as a content box dimension.
valueIsBorderBox = offsetProp in elem;
if ( valueIsBorderBox ) {
	val = elem[ offsetProp ];
}
}
6946
// Normalize "" and auto
val = parseFloat( val ) || 0;
6949
// Adjust for the element's box model
return ( val +
boxModelAdjustment(
	elem,
	dimension,
	extra || ( isBorderBox ? "border" : "content" ),
	valueIsBorderBox,
	styles,
6958
	// Provide the current computed size to request scroll gutter calculation (gh-3589)
	val
)
) + "px";
6963}
6964
6965jQuery.extend( {
6966
// Add in style property hooks for overriding the default
// behavior of getting and setting a style property
cssHooks: {
opacity: {
	get: function( elem, computed ) {
		if ( computed ) {
6973
			// We should always get a number back from opacity
			var ret = curCSS( elem, "opacity" );
			return ret === "" ? "1" : ret;
		}
	}
}
},
6981
// Don't automatically add "px" to these possibly-unitless properties
cssNumber: {
"animationIterationCount": true,
"columnCount": true,
"fillOpacity": true,
"flexGrow": true,
"flexShrink": true,
"fontWeight": true,
"gridArea": true,
"gridColumn": true,
"gridColumnEnd": true,
"gridColumnStart": true,
"gridRow": true,
"gridRowEnd": true,
"gridRowStart": true,
"lineHeight": true,
"opacity": true,
"order": true,
"orphans": true,
"widows": true,
"zIndex": true,
"zoom": true
},
7005
// Add in properties whose names you wish to fix before
// setting or getting the value
cssProps: {},
7009
// Get and set the style property on a DOM Node
style: function( elem, name, value, extra ) {
7012
// Don't set styles on text and comment nodes
if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
	return;
}
7017
// Make sure that we're working with the right name
var ret, type, hooks,
	origName = camelCase( name ),
	isCustomProp = rcustomProp.test( name ),
	style = elem.style;
7023
// Make sure that we're working with the right name. We don't
// want to query the value if it is a CSS custom property
// since they are user-defined.
if ( !isCustomProp ) {
	name = finalPropName( origName );
}
7030
// Gets hook for the prefixed version, then unprefixed version
hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
7033
// Check if we're setting a value
if ( value !== undefined ) {
	type = typeof value;
7037
	// Convert "+=" or "-=" to relative numbers (trac-7345)
	if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
		value = adjustCSS( elem, name, ret );
7041
		// Fixes bug trac-9237
		type = "number";
	}
7045
	// Make sure that null and NaN values aren't set (trac-7116)
	if ( value == null || value !== value ) {
		return;
	}
7050
	// If a number was passed in, add the unit (except for certain CSS properties)
	// The isCustomProp check can be removed in jQuery 4.0 when we only auto-append
	// "px" to a few hardcoded values.
	if ( type === "number" && !isCustomProp ) {
		value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
	}
7057
	// background-* props affect original clone's values
	if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
		style[ name ] = "inherit";
	}
7062
	// If a hook was provided, use that value, otherwise just set the specified value
	if ( !hooks || !( "set" in hooks ) ||
		( value = hooks.set( elem, value, extra ) ) !== undefined ) {
7066
		if ( isCustomProp ) {
			style.setProperty( name, value );
		} else {
			style[ name ] = value;
		}
	}
7073
} else {
7075
	// If a hook was provided get the non-computed value from there
	if ( hooks && "get" in hooks &&
		( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
7079
		return ret;
	}
7082
	// Otherwise just get the value from the style object
	return style[ name ];
}
},
7087
css: function( elem, name, extra, styles ) {
var val, num, hooks,
	origName = camelCase( name ),
	isCustomProp = rcustomProp.test( name );
7092
// Make sure that we're working with the right name. We don't
// want to modify the value if it is a CSS custom property
// since they are user-defined.
if ( !isCustomProp ) {
	name = finalPropName( origName );
}
7099
// Try prefixed name followed by the unprefixed name
hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
7102
// If a hook was provided get the computed value from there
if ( hooks && "get" in hooks ) {
	val = hooks.get( elem, true, extra );
}
7107
// Otherwise, if a way to get the computed value exists, use that
if ( val === undefined ) {
	val = curCSS( elem, name, styles );
}
7112
// Convert "normal" to computed value
if ( val === "normal" && name in cssNormalTransform ) {
	val = cssNormalTransform[ name ];
}
7117
// Make numeric if forced or a qualifier was provided and val looks numeric
if ( extra === "" || extra ) {
	num = parseFloat( val );
	return extra === true || isFinite( num ) ? num || 0 : val;
}
7123
return val;
}
7126} );
7127
7128jQuery.each( [ "height", "width" ], function( _i, dimension ) {
jQuery.cssHooks[ dimension ] = {
get: function( elem, computed, extra ) {
	if ( computed ) {
7132
		// Certain elements can have dimension info if we invisibly show them
		// but it must have a current display style that would benefit
		return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
7136
			// Support: Safari 8+
			// Table columns in Safari have non-zero offsetWidth & zero
			// getBoundingClientRect().width unless display is changed.
			// Support: IE <=11 only
			// Running getBoundingClientRect on a disconnected node
			// in IE throws an error.
			( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
			swap( elem, cssShow, function() {
				return getWidthOrHeight( elem, dimension, extra );
			} ) :
			getWidthOrHeight( elem, dimension, extra );
	}
},
7150
set: function( elem, value, extra ) {
	var matches,
		styles = getStyles( elem ),
7154
		// Only read styles.position if the test has a chance to fail
		// to avoid forcing a reflow.
		scrollboxSizeBuggy = !support.scrollboxSize() &&
			styles.position === "absolute",
7159
		// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)
		boxSizingNeeded = scrollboxSizeBuggy || extra,
		isBorderBox = boxSizingNeeded &&
			jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
		subtract = extra ?
			boxModelAdjustment(
				elem,
				dimension,
				extra,
				isBorderBox,
				styles
			) :
			0;
7173
	// Account for unreliable border-box dimensions by comparing offset* to computed and
	// faking a content-box to get border and padding (gh-3699)
	if ( isBorderBox && scrollboxSizeBuggy ) {
		subtract -= Math.ceil(
			elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
			parseFloat( styles[ dimension ] ) -
			boxModelAdjustment( elem, dimension, "border", false, styles ) -
			0.5
		);
	}
7184
	// Convert to pixels if value adjustment is needed
	if ( subtract && ( matches = rcssNum.exec( value ) ) &&
		( matches[ 3 ] || "px" ) !== "px" ) {
7188
		elem.style[ dimension ] = value;
		value = jQuery.css( elem, dimension );
	}
7192
	return setPositiveNumber( elem, value, subtract );
}
};
7196} );
7197
7198jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
function( elem, computed ) {
if ( computed ) {
	return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
		elem.getBoundingClientRect().left -
			swap( elem, { marginLeft: 0 }, function() {
				return elem.getBoundingClientRect().left;
			} )
	) + "px";
}
}
7209);
7210
7211// These hooks are used by animate to expand properties
7212jQuery.each( {
margin: "",
padding: "",
border: "Width"
7216}, function( prefix, suffix ) {
jQuery.cssHooks[ prefix + suffix ] = {
expand: function( value ) {
	var i = 0,
		expanded = {},
7221
		// Assumes a single number if not a string
		parts = typeof value === "string" ? value.split( " " ) : [ value ];
7224
	for ( ; i < 4; i++ ) {
		expanded[ prefix + cssExpand[ i ] + suffix ] =
			parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
	}
7229
	return expanded;
}
};
7233
if ( prefix !== "margin" ) {
jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
}
7237} );
7238
7239jQuery.fn.extend( {
css: function( name, value ) {
return access( this, function( elem, name, value ) {
	var styles, len,
		map = {},
		i = 0;
7245
	if ( Array.isArray( name ) ) {
		styles = getStyles( elem );
		len = name.length;
7249
		for ( ; i < len; i++ ) {
			map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
		}
7253
		return map;
	}
7256
	return value !== undefined ?
		jQuery.style( elem, name, value ) :
		jQuery.css( elem, name );
}, name, value, arguments.length > 1 );
}
7262} );
7263
7264
7265function Tween( elem, options, prop, end, easing ) {
return new Tween.prototype.init( elem, options, prop, end, easing );
7267}
7268jQuery.Tween = Tween;
7269
7270Tween.prototype = {
constructor: Tween,
init: function( elem, options, prop, end, easing, unit ) {
this.elem = elem;
this.prop = prop;
this.easing = easing || jQuery.easing._default;
this.options = options;
this.start = this.now = this.cur();
this.end = end;
this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
},
cur: function() {
var hooks = Tween.propHooks[ this.prop ];
7283
return hooks && hooks.get ?
	hooks.get( this ) :
	Tween.propHooks._default.get( this );
},
run: function( percent ) {
var eased,
	hooks = Tween.propHooks[ this.prop ];
7291
if ( this.options.duration ) {
	this.pos = eased = jQuery.easing[ this.easing ](
		percent, this.options.duration * percent, 0, 1, this.options.duration
	);
} else {
	this.pos = eased = percent;
}
this.now = ( this.end - this.start ) * eased + this.start;
7300
if ( this.options.step ) {
	this.options.step.call( this.elem, this.now, this );
}
7304
if ( hooks && hooks.set ) {
	hooks.set( this );
} else {
	Tween.propHooks._default.set( this );
}
return this;
}
7312};
7313
7314Tween.prototype.init.prototype = Tween.prototype;
7315
7316Tween.propHooks = {
_default: {
get: function( tween ) {
	var result;
7320
	// Use a property on the element directly when it is not a DOM element,
	// or when there is no matching style property that exists.
	if ( tween.elem.nodeType !== 1 ||
		tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
		return tween.elem[ tween.prop ];
	}
7327
	// Passing an empty string as a 3rd parameter to .css will automatically
	// attempt a parseFloat and fallback to a string if the parse fails.
	// Simple values such as "10px" are parsed to Float;
	// complex values such as "rotate(1rad)" are returned as-is.
	result = jQuery.css( tween.elem, tween.prop, "" );
7333
	// Empty strings, null, undefined and "auto" are converted to 0.
	return !result || result === "auto" ? 0 : result;
},
set: function( tween ) {
7338
	// Use step hook for back compat.
	// Use cssHook if its there.
	// Use .style if available and use plain properties where available.
	if ( jQuery.fx.step[ tween.prop ] ) {
		jQuery.fx.step[ tween.prop ]( tween );
	} else if ( tween.elem.nodeType === 1 && (
		jQuery.cssHooks[ tween.prop ] ||
			tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {
		jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
	} else {
		tween.elem[ tween.prop ] = tween.now;
	}
}
}
7353};
7354
7355// Support: IE <=9 only
7356// Panic based approach to setting things on disconnected nodes
7357Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
set: function( tween ) {
if ( tween.elem.nodeType && tween.elem.parentNode ) {
	tween.elem[ tween.prop ] = tween.now;
}
}
7363};
7364
7365jQuery.easing = {
linear: function( p ) {
return p;
},
swing: function( p ) {
return 0.5 - Math.cos( p * Math.PI ) / 2;
},
_default: "swing"
7373};
7374
7375jQuery.fx = Tween.prototype.init;
7376
7377// Back compat <1.8 extension point
7378jQuery.fx.step = {};
7379
7380
7381
7382
7383var
fxNow, inProgress,
rfxtypes = /^(?:toggle|show|hide)$/,
rrun = /queueHooks$/;
7387
7388function schedule() {
if ( inProgress ) {
if ( document.hidden === false && window.requestAnimationFrame ) {
	window.requestAnimationFrame( schedule );
} else {
	window.setTimeout( schedule, jQuery.fx.interval );
}
7395
jQuery.fx.tick();
}
7398}
7399
7400// Animations created synchronously will run synchronously
7401function createFxNow() {
window.setTimeout( function() {
fxNow = undefined;
} );
return ( fxNow = Date.now() );
7406}
7407
7408// Generate parameters to create a standard animation
7409function genFx( type, includeWidth ) {
var which,
i = 0,
attrs = { height: type };
7413
// If we include width, step value is 1 to do all cssExpand values,
// otherwise step value is 2 to skip over Left and Right
includeWidth = includeWidth ? 1 : 0;
for ( ; i < 4; i += 2 - includeWidth ) {
which = cssExpand[ i ];
attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
}
7421
if ( includeWidth ) {
attrs.opacity = attrs.width = type;
}
7425
return attrs;
7427}
7428
7429function createTween( value, prop, animation ) {
var tween,
collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
index = 0,
length = collection.length;
for ( ; index < length; index++ ) {
if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
7436
	// We're done with this property
	return tween;
}
}
7441}
7442
7443function defaultPrefilter( elem, props, opts ) {
var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
isBox = "width" in props || "height" in props,
anim = this,
orig = {},
style = elem.style,
hidden = elem.nodeType && isHiddenWithinTree( elem ),
dataShow = dataPriv.get( elem, "fxshow" );
7451
// Queue-skipping animations hijack the fx hooks
if ( !opts.queue ) {
hooks = jQuery._queueHooks( elem, "fx" );
if ( hooks.unqueued == null ) {
	hooks.unqueued = 0;
	oldfire = hooks.empty.fire;
	hooks.empty.fire = function() {
		if ( !hooks.unqueued ) {
			oldfire();
		}
	};
}
hooks.unqueued++;
7465
anim.always( function() {
7467
	// Ensure the complete handler is called before this completes
	anim.always( function() {
		hooks.unqueued--;
		if ( !jQuery.queue( elem, "fx" ).length ) {
			hooks.empty.fire();
		}
	} );
} );
}
7477
// Detect show/hide animations
for ( prop in props ) {
value = props[ prop ];
if ( rfxtypes.test( value ) ) {
	delete props[ prop ];
	toggle = toggle || value === "toggle";
	if ( value === ( hidden ? "hide" : "show" ) ) {
7485
		// Pretend to be hidden if this is a "show" and
		// there is still data from a stopped show/hide
		if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
			hidden = true;
7490
		// Ignore all other no-op show/hide data
		} else {
			continue;
		}
	}
	orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
}
}
7499
// Bail out if this is a no-op like .hide().hide()
propTween = !jQuery.isEmptyObject( props );
if ( !propTween && jQuery.isEmptyObject( orig ) ) {
return;
}
7505
// Restrict "overflow" and "display" styles during box animations
if ( isBox && elem.nodeType === 1 ) {
7508
// Support: IE <=9 - 11, Edge 12 - 15
// Record all 3 overflow attributes because IE does not infer the shorthand
// from identically-valued overflowX and overflowY and Edge just mirrors
// the overflowX value there.
opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
7514
// Identify a display type, preferring old show/hide data over the CSS cascade
restoreDisplay = dataShow && dataShow.display;
if ( restoreDisplay == null ) {
	restoreDisplay = dataPriv.get( elem, "display" );
}
display = jQuery.css( elem, "display" );
if ( display === "none" ) {
	if ( restoreDisplay ) {
		display = restoreDisplay;
	} else {
7525
		// Get nonempty value(s) by temporarily forcing visibility
		showHide( [ elem ], true );
		restoreDisplay = elem.style.display || restoreDisplay;
		display = jQuery.css( elem, "display" );
		showHide( [ elem ] );
	}
}
7533
// Animate inline elements as inline-block
if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
	if ( jQuery.css( elem, "float" ) === "none" ) {
7537
		// Restore the original display value at the end of pure show/hide animations
		if ( !propTween ) {
			anim.done( function() {
				style.display = restoreDisplay;
			} );
			if ( restoreDisplay == null ) {
				display = style.display;
				restoreDisplay = display === "none" ? "" : display;
			}
		}
		style.display = "inline-block";
	}
}
}
7552
if ( opts.overflow ) {
style.overflow = "hidden";
anim.always( function() {
	style.overflow = opts.overflow[ 0 ];
	style.overflowX = opts.overflow[ 1 ];
	style.overflowY = opts.overflow[ 2 ];
} );
}
7561
// Implement show/hide animations
propTween = false;
for ( prop in orig ) {
7565
// General show/hide setup for this element animation
if ( !propTween ) {
	if ( dataShow ) {
		if ( "hidden" in dataShow ) {
			hidden = dataShow.hidden;
		}
	} else {
		dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
	}
7575
	// Store hidden/visible for toggle so `.stop().toggle()` "reverses"
	if ( toggle ) {
		dataShow.hidden = !hidden;
	}
7580
	// Show elements before animating them
	if ( hidden ) {
		showHide( [ elem ], true );
	}
7585
	/* eslint-disable no-loop-func */
7587
	anim.done( function() {
7589
		/* eslint-enable no-loop-func */
7591
		// The final step of a "hide" animation is actually hiding the element
		if ( !hidden ) {
			showHide( [ elem ] );
		}
		dataPriv.remove( elem, "fxshow" );
		for ( prop in orig ) {
			jQuery.style( elem, prop, orig[ prop ] );
		}
	} );
}
7602
// Per-property setup
propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
if ( !( prop in dataShow ) ) {
	dataShow[ prop ] = propTween.start;
	if ( hidden ) {
		propTween.end = propTween.start;
		propTween.start = 0;
	}
}
}
7613}
7614
7615function propFilter( props, specialEasing ) {
var index, name, easing, value, hooks;
7617
// camelCase, specialEasing and expand cssHook pass
for ( index in props ) {
name = camelCase( index );
easing = specialEasing[ name ];
value = props[ index ];
if ( Array.isArray( value ) ) {
	easing = value[ 1 ];
	value = props[ index ] = value[ 0 ];
}
7627
if ( index !== name ) {
	props[ name ] = value;
	delete props[ index ];
}
7632
hooks = jQuery.cssHooks[ name ];
if ( hooks && "expand" in hooks ) {
	value = hooks.expand( value );
	delete props[ name ];
7637
	// Not quite $.extend, this won't overwrite existing keys.
	// Reusing 'index' because we have the correct "name"
	for ( index in value ) {
		if ( !( index in props ) ) {
			props[ index ] = value[ index ];
			specialEasing[ index ] = easing;
		}
	}
} else {
	specialEasing[ name ] = easing;
}
}
7650}
7651
7652function Animation( elem, properties, options ) {
var result,
stopped,
index = 0,
length = Animation.prefilters.length,
deferred = jQuery.Deferred().always( function() {
7658
	// Don't match elem in the :animated selector
	delete tick.elem;
} ),
tick = function() {
	if ( stopped ) {
		return false;
	}
	var currentTime = fxNow || createFxNow(),
		remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
7668
		// Support: Android 2.3 only
		// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (trac-12497)
		temp = remaining / animation.duration || 0,
		percent = 1 - temp,
		index = 0,
		length = animation.tweens.length;
7675
	for ( ; index < length; index++ ) {
		animation.tweens[ index ].run( percent );
	}
7679
	deferred.notifyWith( elem, [ animation, percent, remaining ] );
7681
	// If there's more to do, yield
	if ( percent < 1 && length ) {
		return remaining;
	}
7686
	// If this was an empty animation, synthesize a final progress notification
	if ( !length ) {
		deferred.notifyWith( elem, [ animation, 1, 0 ] );
	}
7691
	// Resolve the animation and report its conclusion
	deferred.resolveWith( elem, [ animation ] );
	return false;
},
animation = deferred.promise( {
	elem: elem,
	props: jQuery.extend( {}, properties ),
	opts: jQuery.extend( true, {
		specialEasing: {},
		easing: jQuery.easing._default
	}, options ),
	originalProperties: properties,
	originalOptions: options,
	startTime: fxNow || createFxNow(),
	duration: options.duration,
	tweens: [],
	createTween: function( prop, end ) {
		var tween = jQuery.Tween( elem, animation.opts, prop, end,
			animation.opts.specialEasing[ prop ] || animation.opts.easing );
		animation.tweens.push( tween );
		return tween;
	},
	stop: function( gotoEnd ) {
		var index = 0,
7716
			// If we are going to the end, we want to run all the tweens
			// otherwise we skip this part
			length = gotoEnd ? animation.tweens.length : 0;
		if ( stopped ) {
			return this;
		}
		stopped = true;
		for ( ; index < length; index++ ) {
			animation.tweens[ index ].run( 1 );
		}
7727
		// Resolve when we played the last frame; otherwise, reject
		if ( gotoEnd ) {
			deferred.notifyWith( elem, [ animation, 1, 0 ] );
			deferred.resolveWith( elem, [ animation, gotoEnd ] );
		} else {
			deferred.rejectWith( elem, [ animation, gotoEnd ] );
		}
		return this;
	}
} ),
props = animation.props;
7739
propFilter( props, animation.opts.specialEasing );
7741
for ( ; index < length; index++ ) {
result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
if ( result ) {
	if ( isFunction( result.stop ) ) {
		jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
			result.stop.bind( result );
	}
	return result;
}
}
7752
jQuery.map( props, createTween, animation );
7754
if ( isFunction( animation.opts.start ) ) {
animation.opts.start.call( elem, animation );
}
7758
// Attach callbacks from options
animation
.progress( animation.opts.progress )
.done( animation.opts.done, animation.opts.complete )
.fail( animation.opts.fail )
.always( animation.opts.always );
7765
jQuery.fx.timer(
jQuery.extend( tick, {
	elem: elem,
	anim: animation,
	queue: animation.opts.queue
} )
);
7773
return animation;
7775}
7776
7777jQuery.Animation = jQuery.extend( Animation, {
7778
tweeners: {
"*": [ function( prop, value ) {
	var tween = this.createTween( prop, value );
	adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
	return tween;
} ]
},
7786
tweener: function( props, callback ) {
if ( isFunction( props ) ) {
	callback = props;
	props = [ "*" ];
} else {
	props = props.match( rnothtmlwhite );
}
7794
var prop,
	index = 0,
	length = props.length;
7798
for ( ; index < length; index++ ) {
	prop = props[ index ];
	Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
	Animation.tweeners[ prop ].unshift( callback );
}
},
7805
prefilters: [ defaultPrefilter ],
7807
prefilter: function( callback, prepend ) {
if ( prepend ) {
	Animation.prefilters.unshift( callback );
} else {
	Animation.prefilters.push( callback );
}
}
7815} );
7816
7817jQuery.speed = function( speed, easing, fn ) {
var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
complete: fn || !fn && easing ||
	isFunction( speed ) && speed,
duration: speed,
easing: fn && easing || easing && !isFunction( easing ) && easing
};
7824
// Go to the end state if fx are off
if ( jQuery.fx.off ) {
opt.duration = 0;
7828
} else {
if ( typeof opt.duration !== "number" ) {
	if ( opt.duration in jQuery.fx.speeds ) {
		opt.duration = jQuery.fx.speeds[ opt.duration ];
7833
	} else {
		opt.duration = jQuery.fx.speeds._default;
	}
}
}
7839
// Normalize opt.queue - true/undefined/null -> "fx"
if ( opt.queue == null || opt.queue === true ) {
opt.queue = "fx";
}
7844
// Queueing
opt.old = opt.complete;
7847
opt.complete = function() {
if ( isFunction( opt.old ) ) {
	opt.old.call( this );
}
7852
if ( opt.queue ) {
	jQuery.dequeue( this, opt.queue );
}
};
7857
return opt;
7859};
7860
7861jQuery.fn.extend( {
fadeTo: function( speed, to, easing, callback ) {
7863
// Show any hidden elements after setting opacity to 0
return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
7866
	// Animate to the value specified
	.end().animate( { opacity: to }, speed, easing, callback );
},
animate: function( prop, speed, easing, callback ) {
var empty = jQuery.isEmptyObject( prop ),
	optall = jQuery.speed( speed, easing, callback ),
	doAnimation = function() {
7874
		// Operate on a copy of prop so per-property easing won't be lost
		var anim = Animation( this, jQuery.extend( {}, prop ), optall );
7877
		// Empty animations, or finishing resolves immediately
		if ( empty || dataPriv.get( this, "finish" ) ) {
			anim.stop( true );
		}
	};
7883
doAnimation.finish = doAnimation;
7885
return empty || optall.queue === false ?
	this.each( doAnimation ) :
	this.queue( optall.queue, doAnimation );
},
stop: function( type, clearQueue, gotoEnd ) {
var stopQueue = function( hooks ) {
	var stop = hooks.stop;
	delete hooks.stop;
	stop( gotoEnd );
};
7896
if ( typeof type !== "string" ) {
	gotoEnd = clearQueue;
	clearQueue = type;
	type = undefined;
}
if ( clearQueue ) {
	this.queue( type || "fx", [] );
}
7905
return this.each( function() {
	var dequeue = true,
		index = type != null && type + "queueHooks",
		timers = jQuery.timers,
		data = dataPriv.get( this );
7911
	if ( index ) {
		if ( data[ index ] && data[ index ].stop ) {
			stopQueue( data[ index ] );
		}
	} else {
		for ( index in data ) {
			if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
				stopQueue( data[ index ] );
			}
		}
	}
7923
	for ( index = timers.length; index--; ) {
		if ( timers[ index ].elem === this &&
			( type == null || timers[ index ].queue === type ) ) {
7927
			timers[ index ].anim.stop( gotoEnd );
			dequeue = false;
			timers.splice( index, 1 );
		}
	}
7933
	// Start the next in the queue if the last step wasn't forced.
	// Timers currently will call their complete callbacks, which
	// will dequeue but only if they were gotoEnd.
	if ( dequeue || !gotoEnd ) {
		jQuery.dequeue( this, type );
	}
} );
},
finish: function( type ) {
if ( type !== false ) {
	type = type || "fx";
}
return this.each( function() {
	var index,
		data = dataPriv.get( this ),
		queue = data[ type + "queue" ],
		hooks = data[ type + "queueHooks" ],
		timers = jQuery.timers,
		length = queue ? queue.length : 0;
7953
	// Enable finishing flag on private data
	data.finish = true;
7956
	// Empty the queue first
	jQuery.queue( this, type, [] );
7959
	if ( hooks && hooks.stop ) {
		hooks.stop.call( this, true );
	}
7963
	// Look for any active animations, and finish them
	for ( index = timers.length; index--; ) {
		if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
			timers[ index ].anim.stop( true );
			timers.splice( index, 1 );
		}
	}
7971
	// Look for any animations in the old queue and finish them
	for ( index = 0; index < length; index++ ) {
		if ( queue[ index ] && queue[ index ].finish ) {
			queue[ index ].finish.call( this );
		}
	}
7978
	// Turn off finishing flag
	delete data.finish;
} );
}
7983} );
7984
7985jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) {
var cssFn = jQuery.fn[ name ];
jQuery.fn[ name ] = function( speed, easing, callback ) {
return speed == null || typeof speed === "boolean" ?
	cssFn.apply( this, arguments ) :
	this.animate( genFx( name, true ), speed, easing, callback );
};
7992} );
7993
7994// Generate shortcuts for custom animations
7995jQuery.each( {
slideDown: genFx( "show" ),
slideUp: genFx( "hide" ),
slideToggle: genFx( "toggle" ),
fadeIn: { opacity: "show" },
fadeOut: { opacity: "hide" },
fadeToggle: { opacity: "toggle" }
8002}, function( name, props ) {
jQuery.fn[ name ] = function( speed, easing, callback ) {
return this.animate( props, speed, easing, callback );
};
8006} );
8007
8008jQuery.timers = [];
8009jQuery.fx.tick = function() {
var timer,
i = 0,
timers = jQuery.timers;
8013
fxNow = Date.now();
8015
for ( ; i < timers.length; i++ ) {
timer = timers[ i ];
8018
// Run the timer and safely remove it when done (allowing for external removal)
if ( !timer() && timers[ i ] === timer ) {
	timers.splice( i--, 1 );
}
}
8024
if ( !timers.length ) {
jQuery.fx.stop();
}
fxNow = undefined;
8029};
8030
8031jQuery.fx.timer = function( timer ) {
jQuery.timers.push( timer );
jQuery.fx.start();
8034};
8035
8036jQuery.fx.interval = 13;
8037jQuery.fx.start = function() {
if ( inProgress ) {
return;
}
8041
inProgress = true;
schedule();
8044};
8045
8046jQuery.fx.stop = function() {
inProgress = null;
8048};
8049
8050jQuery.fx.speeds = {
slow: 600,
fast: 200,
8053
// Default speed
_default: 400
8056};
8057
8058
8059// Based off of the plugin by Clint Helfers, with permission.
8060jQuery.fn.delay = function( time, type ) {
time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
type = type || "fx";
8063
return this.queue( type, function( next, hooks ) {
var timeout = window.setTimeout( next, time );
hooks.stop = function() {
	window.clearTimeout( timeout );
};
} );
8070};
8071
8072
8073( function() {
var input = document.createElement( "input" ),
select = document.createElement( "select" ),
opt = select.appendChild( document.createElement( "option" ) );
8077
input.type = "checkbox";
8079
// Support: Android <=4.3 only
// Default value for a checkbox should be "on"
support.checkOn = input.value !== "";
8083
// Support: IE <=11 only
// Must access selectedIndex to make default options select
support.optSelected = opt.selected;
8087
// Support: IE <=11 only
// An input loses its value after becoming a radio
input = document.createElement( "input" );
input.value = "t";
input.type = "radio";
support.radioValue = input.value === "t";
8094} )();
8095
8096
8097var boolHook,
attrHandle = jQuery.expr.attrHandle;
8099
8100jQuery.fn.extend( {
attr: function( name, value ) {
return access( this, jQuery.attr, name, value, arguments.length > 1 );
},
8104
removeAttr: function( name ) {
return this.each( function() {
	jQuery.removeAttr( this, name );
} );
}
8110} );
8111
8112jQuery.extend( {
attr: function( elem, name, value ) {
var ret, hooks,
	nType = elem.nodeType;
8116
// Don't get/set attributes on text, comment and attribute nodes
if ( nType === 3 || nType === 8 || nType === 2 ) {
	return;
}
8121
// Fallback to prop when attributes are not supported
if ( typeof elem.getAttribute === "undefined" ) {
	return jQuery.prop( elem, name, value );
}
8126
// Attribute hooks are determined by the lowercase version
// Grab necessary hook if one is defined
if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
	hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
		( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
}
8133
if ( value !== undefined ) {
	if ( value === null ) {
		jQuery.removeAttr( elem, name );
		return;
	}
8139
	if ( hooks && "set" in hooks &&
		( ret = hooks.set( elem, value, name ) ) !== undefined ) {
		return ret;
	}
8144
	elem.setAttribute( name, value + "" );
	return value;
}
8148
if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
	return ret;
}
8152
ret = jQuery.find.attr( elem, name );
8154
// Non-existent attributes return null, we normalize to undefined
return ret == null ? undefined : ret;
},
8158
attrHooks: {
type: {
	set: function( elem, value ) {
		if ( !support.radioValue && value === "radio" &&
			nodeName( elem, "input" ) ) {
			var val = elem.value;
			elem.setAttribute( "type", value );
			if ( val ) {
				elem.value = val;
			}
			return value;
		}
	}
}
},
8174
removeAttr: function( elem, value ) {
var name,
	i = 0,
8178
	// Attribute names can contain non-HTML whitespace characters
	// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
	attrNames = value && value.match( rnothtmlwhite );
8182
if ( attrNames && elem.nodeType === 1 ) {
	while ( ( name = attrNames[ i++ ] ) ) {
		elem.removeAttribute( name );
	}
}
}
8189} );
8190
8191// Hooks for boolean attributes
8192boolHook = {
set: function( elem, value, name ) {
if ( value === false ) {
8195
	// Remove boolean attributes when set to false
	jQuery.removeAttr( elem, name );
} else {
	elem.setAttribute( name, name );
}
return name;
}
8203};
8204
8205jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) {
var getter = attrHandle[ name ] || jQuery.find.attr;
8207
attrHandle[ name ] = function( elem, name, isXML ) {
var ret, handle,
	lowercaseName = name.toLowerCase();
8211
if ( !isXML ) {
8213
	// Avoid an infinite loop by temporarily removing this function from the getter
	handle = attrHandle[ lowercaseName ];
	attrHandle[ lowercaseName ] = ret;
	ret = getter( elem, name, isXML ) != null ?
		lowercaseName :
		null;
	attrHandle[ lowercaseName ] = handle;
}
return ret;
};
8224} );
8225
8226
8227
8228
8229var rfocusable = /^(?:input|select|textarea|button)$/i,
rclickable = /^(?:a|area)$/i;
8231
8232jQuery.fn.extend( {
prop: function( name, value ) {
return access( this, jQuery.prop, name, value, arguments.length > 1 );
},
8236
removeProp: function( name ) {
return this.each( function() {
	delete this[ jQuery.propFix[ name ] || name ];
} );
}
8242} );
8243
8244jQuery.extend( {
prop: function( elem, name, value ) {
var ret, hooks,
	nType = elem.nodeType;
8248
// Don't get/set properties on text, comment and attribute nodes
if ( nType === 3 || nType === 8 || nType === 2 ) {
	return;
}
8253
if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
8255
	// Fix name and attach hooks
	name = jQuery.propFix[ name ] || name;
	hooks = jQuery.propHooks[ name ];
}
8260
if ( value !== undefined ) {
	if ( hooks && "set" in hooks &&
		( ret = hooks.set( elem, value, name ) ) !== undefined ) {
		return ret;
	}
8266
	return ( elem[ name ] = value );
}
8269
if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
	return ret;
}
8273
return elem[ name ];
},
8276
propHooks: {
tabIndex: {
	get: function( elem ) {
8280
		// Support: IE <=9 - 11 only
		// elem.tabIndex doesn't always return the
		// correct value when it hasn't been explicitly set
		// Use proper attribute retrieval (trac-12072)
		var tabindex = jQuery.find.attr( elem, "tabindex" );
8286
		if ( tabindex ) {
			return parseInt( tabindex, 10 );
		}
8290
		if (
			rfocusable.test( elem.nodeName ) ||
			rclickable.test( elem.nodeName ) &&
			elem.href
		) {
			return 0;
		}
8298
		return -1;
	}
}
},
8303
propFix: {
"for": "htmlFor",
"class": "className"
}
8308} );
8309
8310// Support: IE <=11 only
8311// Accessing the selectedIndex property
8312// forces the browser to respect setting selected
8313// on the option
8314// The getter ensures a default option is selected
8315// when in an optgroup
8316// eslint rule "no-unused-expressions" is disabled for this code
8317// since it considers such accessions noop
8318if ( !support.optSelected ) {
jQuery.propHooks.selected = {
get: function( elem ) {
8321
	/* eslint no-unused-expressions: "off" */
8323
	var parent = elem.parentNode;
	if ( parent && parent.parentNode ) {
		parent.parentNode.selectedIndex;
	}
	return null;
},
set: function( elem ) {
8331
	/* eslint no-unused-expressions: "off" */
8333
	var parent = elem.parentNode;
	if ( parent ) {
		parent.selectedIndex;
8337
		if ( parent.parentNode ) {
			parent.parentNode.selectedIndex;
		}
	}
}
};
8344}
8345
8346jQuery.each( [
"tabIndex",
"readOnly",
"maxLength",
"cellSpacing",
"cellPadding",
"rowSpan",
"colSpan",
"useMap",
"frameBorder",
"contentEditable"
8357], function() {
jQuery.propFix[ this.toLowerCase() ] = this;
8359} );
8360
8361
8362
8363
// Strip and collapse whitespace according to HTML spec
// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
function stripAndCollapse( value ) {
var tokens = value.match( rnothtmlwhite ) || [];
return tokens.join( " " );
}
8370
8371
8372function getClass( elem ) {
return elem.getAttribute && elem.getAttribute( "class" ) || "";
8374}
8375
8376function classesToArray( value ) {
if ( Array.isArray( value ) ) {
return value;
}
if ( typeof value === "string" ) {
return value.match( rnothtmlwhite ) || [];
}
return [];
8384}
8385
8386jQuery.fn.extend( {
addClass: function( value ) {
var classNames, cur, curValue, className, i, finalValue;
8389
if ( isFunction( value ) ) {
	return this.each( function( j ) {
		jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
	} );
}
8395
classNames = classesToArray( value );
8397
if ( classNames.length ) {
	return this.each( function() {
		curValue = getClass( this );
		cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
8402
		if ( cur ) {
			for ( i = 0; i < classNames.length; i++ ) {
				className = classNames[ i ];
				if ( cur.indexOf( " " + className + " " ) < 0 ) {
					cur += className + " ";
				}
			}
8410
			// Only assign if different to avoid unneeded rendering.
			finalValue = stripAndCollapse( cur );
			if ( curValue !== finalValue ) {
				this.setAttribute( "class", finalValue );
			}
		}
	} );
}
8419
return this;
},
8422
removeClass: function( value ) {
var classNames, cur, curValue, className, i, finalValue;
8425
if ( isFunction( value ) ) {
	return this.each( function( j ) {
		jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
	} );
}
8431
if ( !arguments.length ) {
	return this.attr( "class", "" );
}
8435
classNames = classesToArray( value );
8437
if ( classNames.length ) {
	return this.each( function() {
		curValue = getClass( this );
8441
		// This expression is here for better compressibility (see addClass)
		cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
8444
		if ( cur ) {
			for ( i = 0; i < classNames.length; i++ ) {
				className = classNames[ i ];
8448
				// Remove *all* instances
				while ( cur.indexOf( " " + className + " " ) > -1 ) {
					cur = cur.replace( " " + className + " ", " " );
				}
			}
8454
			// Only assign if different to avoid unneeded rendering.
			finalValue = stripAndCollapse( cur );
			if ( curValue !== finalValue ) {
				this.setAttribute( "class", finalValue );
			}
		}
	} );
}
8463
return this;
},
8466
toggleClass: function( value, stateVal ) {
var classNames, className, i, self,
	type = typeof value,
	isValidValue = type === "string" || Array.isArray( value );
8471
if ( isFunction( value ) ) {
	return this.each( function( i ) {
		jQuery( this ).toggleClass(
			value.call( this, i, getClass( this ), stateVal ),
			stateVal
		);
	} );
}
8480
if ( typeof stateVal === "boolean" && isValidValue ) {
	return stateVal ? this.addClass( value ) : this.removeClass( value );
}
8484
classNames = classesToArray( value );
8486
return this.each( function() {
	if ( isValidValue ) {
8489
		// Toggle individual class names
		self = jQuery( this );
8492
		for ( i = 0; i < classNames.length; i++ ) {
			className = classNames[ i ];
8495
			// Check each className given, space separated list
			if ( self.hasClass( className ) ) {
				self.removeClass( className );
			} else {
				self.addClass( className );
			}
		}
8503
	// Toggle whole class name
	} else if ( value === undefined || type === "boolean" ) {
		className = getClass( this );
		if ( className ) {
8508
			// Store className if set
			dataPriv.set( this, "__className__", className );
		}
8512
		// If the element has a class name or if we're passed `false`,
		// then remove the whole classname (if there was one, the above saved it).
		// Otherwise bring back whatever was previously saved (if anything),
		// falling back to the empty string if nothing was stored.
		if ( this.setAttribute ) {
			this.setAttribute( "class",
				className || value === false ?
					"" :
					dataPriv.get( this, "__className__" ) || ""
			);
		}
	}
} );
},
8527
hasClass: function( selector ) {
var className, elem,
	i = 0;
8531
className = " " + selector + " ";
while ( ( elem = this[ i++ ] ) ) {
	if ( elem.nodeType === 1 &&
		( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
		return true;
	}
}
8539
return false;
}
8542} );
8543
8544
8545
8546
8547var rreturn = /\r/g;
8548
8549jQuery.fn.extend( {
val: function( value ) {
var hooks, ret, valueIsFunction,
	elem = this[ 0 ];
8553
if ( !arguments.length ) {
	if ( elem ) {
		hooks = jQuery.valHooks[ elem.type ] ||
			jQuery.valHooks[ elem.nodeName.toLowerCase() ];
8558
		if ( hooks &&
			"get" in hooks &&
			( ret = hooks.get( elem, "value" ) ) !== undefined
		) {
			return ret;
		}
8565
		ret = elem.value;
8567
		// Handle most common string cases
		if ( typeof ret === "string" ) {
			return ret.replace( rreturn, "" );
		}
8572
		// Handle cases where value is null/undef or number
		return ret == null ? "" : ret;
	}
8576
	return;
}
8579
valueIsFunction = isFunction( value );
8581
return this.each( function( i ) {
	var val;
8584
	if ( this.nodeType !== 1 ) {
		return;
	}
8588
	if ( valueIsFunction ) {
		val = value.call( this, i, jQuery( this ).val() );
	} else {
		val = value;
	}
8594
	// Treat null/undefined as ""; convert numbers to string
	if ( val == null ) {
		val = "";
8598
	} else if ( typeof val === "number" ) {
		val += "";
8601
	} else if ( Array.isArray( val ) ) {
		val = jQuery.map( val, function( value ) {
			return value == null ? "" : value + "";
		} );
	}
8607
	hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
8609
	// If set returns undefined, fall back to normal setting
	if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
		this.value = val;
	}
} );
}
8616} );
8617
8618jQuery.extend( {
valHooks: {
option: {
	get: function( elem ) {
8622
		var val = jQuery.find.attr( elem, "value" );
		return val != null ?
			val :
8626
			// Support: IE <=10 - 11 only
			// option.text throws exceptions (trac-14686, trac-14858)
			// Strip and collapse whitespace
			// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
			stripAndCollapse( jQuery.text( elem ) );
	}
},
select: {
	get: function( elem ) {
		var value, option, i,
			options = elem.options,
			index = elem.selectedIndex,
			one = elem.type === "select-one",
			values = one ? null : [],
			max = one ? index + 1 : options.length;
8642
		if ( index < 0 ) {
			i = max;
8645
		} else {
			i = one ? index : 0;
		}
8649
		// Loop through all the selected options
		for ( ; i < max; i++ ) {
			option = options[ i ];
8653
			// Support: IE <=9 only
			// IE8-9 doesn't update selected after form reset (trac-2551)
			if ( ( option.selected || i === index ) &&
8657
					// Don't return options that are disabled or in a disabled optgroup
					!option.disabled &&
					( !option.parentNode.disabled ||
						!nodeName( option.parentNode, "optgroup" ) ) ) {
8662
				// Get the specific value for the option
				value = jQuery( option ).val();
8665
				// We don't need an array for one selects
				if ( one ) {
					return value;
				}
8670
				// Multi-Selects return an array
				values.push( value );
			}
		}
8675
		return values;
	},
8678
	set: function( elem, value ) {
		var optionSet, option,
			options = elem.options,
			values = jQuery.makeArray( value ),
			i = options.length;
8684
		while ( i-- ) {
			option = options[ i ];
8687
			/* eslint-disable no-cond-assign */
8689
			if ( option.selected =
				jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
			) {
				optionSet = true;
			}
8695
			/* eslint-enable no-cond-assign */
		}
8698
		// Force browsers to behave consistently when non-matching value is set
		if ( !optionSet ) {
			elem.selectedIndex = -1;
		}
		return values;
	}
}
}
8707} );
8708
8709// Radios and checkboxes getter/setter
8710jQuery.each( [ "radio", "checkbox" ], function() {
jQuery.valHooks[ this ] = {
set: function( elem, value ) {
	if ( Array.isArray( value ) ) {
		return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
	}
}
};
if ( !support.checkOn ) {
jQuery.valHooks[ this ].get = function( elem ) {
	return elem.getAttribute( "value" ) === null ? "on" : elem.value;
};
}
8723} );
8724
8725
8726
8727
8728// Return jQuery for attributes-only inclusion
8729
8730
8731support.focusin = "onfocusin" in window;
8732
8733
8734var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
stopPropagationCallback = function( e ) {
e.stopPropagation();
};
8738
8739jQuery.extend( jQuery.event, {
8740
trigger: function( event, data, elem, onlyHandlers ) {
8742
var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,
	eventPath = [ elem || document ],
	type = hasOwn.call( event, "type" ) ? event.type : event,
	namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
8747
cur = lastElement = tmp = elem = elem || document;
8749
// Don't do events on text and comment nodes
if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
	return;
}
8754
// focus/blur morphs to focusin/out; ensure we're not firing them right now
if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
	return;
}
8759
if ( type.indexOf( "." ) > -1 ) {
8761
	// Namespaced trigger; create a regexp to match event type in handle()
	namespaces = type.split( "." );
	type = namespaces.shift();
	namespaces.sort();
}
ontype = type.indexOf( ":" ) < 0 && "on" + type;
8768
// Caller can pass in a jQuery.Event object, Object, or just an event type string
event = event[ jQuery.expando ] ?
	event :
	new jQuery.Event( type, typeof event === "object" && event );
8773
// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
event.isTrigger = onlyHandlers ? 2 : 3;
event.namespace = namespaces.join( "." );
event.rnamespace = event.namespace ?
	new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
	null;
8780
// Clean up the event in case it is being reused
event.result = undefined;
if ( !event.target ) {
	event.target = elem;
}
8786
// Clone any incoming data and prepend the event, creating the handler arg list
data = data == null ?
	[ event ] :
	jQuery.makeArray( data, [ event ] );
8791
// Allow special events to draw outside the lines
special = jQuery.event.special[ type ] || {};
if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
	return;
}
8797
// Determine event propagation path in advance, per W3C events spec (trac-9951)
// Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724)
if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {
8801
	bubbleType = special.delegateType || type;
	if ( !rfocusMorph.test( bubbleType + type ) ) {
		cur = cur.parentNode;
	}
	for ( ; cur; cur = cur.parentNode ) {
		eventPath.push( cur );
		tmp = cur;
	}
8810
	// Only add window if we got to document (e.g., not plain obj or detached DOM)
	if ( tmp === ( elem.ownerDocument || document ) ) {
		eventPath.push( tmp.defaultView || tmp.parentWindow || window );
	}
}
8816
// Fire handlers on the event path
i = 0;
while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
	lastElement = cur;
	event.type = i > 1 ?
		bubbleType :
		special.bindType || type;
8824
	// jQuery handler
	handle = ( dataPriv.get( cur, "events" ) || Object.create( null ) )[ event.type ] &&
		dataPriv.get( cur, "handle" );
	if ( handle ) {
		handle.apply( cur, data );
	}
8831
	// Native handler
	handle = ontype && cur[ ontype ];
	if ( handle && handle.apply && acceptData( cur ) ) {
		event.result = handle.apply( cur, data );
		if ( event.result === false ) {
			event.preventDefault();
		}
	}
}
event.type = type;
8842
// If nobody prevented the default action, do it now
if ( !onlyHandlers && !event.isDefaultPrevented() ) {
8845
	if ( ( !special._default ||
		special._default.apply( eventPath.pop(), data ) === false ) &&
		acceptData( elem ) ) {
8849
		// Call a native DOM method on the target with the same name as the event.
		// Don't do default actions on window, that's where global variables be (trac-6170)
		if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {
8853
			// Don't re-trigger an onFOO event when we call its FOO() method
			tmp = elem[ ontype ];
8856
			if ( tmp ) {
				elem[ ontype ] = null;
			}
8860
			// Prevent re-triggering of the same event, since we already bubbled it above
			jQuery.event.triggered = type;
8863
			if ( event.isPropagationStopped() ) {
				lastElement.addEventListener( type, stopPropagationCallback );
			}
8867
			elem[ type ]();
8869
			if ( event.isPropagationStopped() ) {
				lastElement.removeEventListener( type, stopPropagationCallback );
			}
8873
			jQuery.event.triggered = undefined;
8875
			if ( tmp ) {
				elem[ ontype ] = tmp;
			}
		}
	}
}
8882
return event.result;
},
8885
// Piggyback on a donor event to simulate a different one
// Used only for `focus(in | out)` events
simulate: function( type, elem, event ) {
var e = jQuery.extend(
	new jQuery.Event(),
	event,
	{
		type: type,
		isSimulated: true
	}
);
8897
jQuery.event.trigger( e, null, elem );
}
8900
8901} );
8902
8903jQuery.fn.extend( {
8904
trigger: function( type, data ) {
return this.each( function() {
	jQuery.event.trigger( type, data, this );
} );
},
triggerHandler: function( type, data ) {
var elem = this[ 0 ];
if ( elem ) {
	return jQuery.event.trigger( type, data, elem, true );
}
}
8916} );
8917
8918
8919// Support: Firefox <=44
8920// Firefox doesn't have focus(in | out) events
8921// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
8922//
8923// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
8924// focus(in | out) events fire after focus & blur events,
8925// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
8926// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
8927if ( !support.focusin ) {
jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
8929
// Attach a single capturing handler on the document while someone wants focusin/focusout
var handler = function( event ) {
	jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
};
8934
jQuery.event.special[ fix ] = {
	setup: function() {
8937
		// Handle: regular nodes (via `this.ownerDocument`), window
		// (via `this.document`) & document (via `this`).
		var doc = this.ownerDocument || this.document || this,
			attaches = dataPriv.access( doc, fix );
8942
		if ( !attaches ) {
			doc.addEventListener( orig, handler, true );
		}
		dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
	},
	teardown: function() {
		var doc = this.ownerDocument || this.document || this,
			attaches = dataPriv.access( doc, fix ) - 1;
8951
		if ( !attaches ) {
			doc.removeEventListener( orig, handler, true );
			dataPriv.remove( doc, fix );
8955
		} else {
			dataPriv.access( doc, fix, attaches );
		}
	}
};
} );
8962}
8963var location = window.location;
8964
8965var nonce = { guid: Date.now() };
8966
8967var rquery = ( /\?/ );
8968
8969
8970
8971// Cross-browser xml parsing
8972jQuery.parseXML = function( data ) {
var xml, parserErrorElem;
if ( !data || typeof data !== "string" ) {
return null;
}
8977
// Support: IE 9 - 11 only
// IE throws on parseFromString with invalid input.
try {
xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
} catch ( e ) {}
8983
parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ];
if ( !xml || parserErrorElem ) {
jQuery.error( "Invalid XML: " + (
	parserErrorElem ?
		jQuery.map( parserErrorElem.childNodes, function( el ) {
			return el.textContent;
		} ).join( "\n" ) :
		data
) );
}
return xml;
8995};
8996
8997
8998var
rbracket = /\[\]$/,
rCRLF = /\r?\n/g,
rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
rsubmittable = /^(?:input|select|textarea|keygen)/i;
9003
9004function buildParams( prefix, obj, traditional, add ) {
var name;
9006
if ( Array.isArray( obj ) ) {
9008
// Serialize array item.
jQuery.each( obj, function( i, v ) {
	if ( traditional || rbracket.test( prefix ) ) {
9012
		// Treat each array item as a scalar.
		add( prefix, v );
9015
	} else {
9017
		// Item is non-scalar (array or object), encode its numeric index.
		buildParams(
			prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
			v,
			traditional,
			add
		);
	}
} );
9027
} else if ( !traditional && toType( obj ) === "object" ) {
9029
// Serialize object item.
for ( name in obj ) {
	buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
}
9034
} else {
9036
// Serialize scalar item.
add( prefix, obj );
}
9040}
9041
9042// Serialize an array of form elements or a set of
9043// key/values into a query string
9044jQuery.param = function( a, traditional ) {
var prefix,
s = [],
add = function( key, valueOrFunction ) {
9048
	// If value is a function, invoke it and use its return value
	var value = isFunction( valueOrFunction ) ?
		valueOrFunction() :
		valueOrFunction;
9053
	s[ s.length ] = encodeURIComponent( key ) + "=" +
		encodeURIComponent( value == null ? "" : value );
};
9057
if ( a == null ) {
return "";
}
9061
// If an array was passed in, assume that it is an array of form elements.
if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
9064
// Serialize the form elements
jQuery.each( a, function() {
	add( this.name, this.value );
} );
9069
} else {
9071
// If traditional, encode the "old" way (the way 1.3.2 or older
// did it), otherwise encode params recursively.
for ( prefix in a ) {
	buildParams( prefix, a[ prefix ], traditional, add );
}
}
9078
// Return the resulting serialization
return s.join( "&" );
9081};
9082
9083jQuery.fn.extend( {
serialize: function() {
return jQuery.param( this.serializeArray() );
},
serializeArray: function() {
return this.map( function() {
9089
	// Can add propHook for "elements" to filter or add form elements
	var elements = jQuery.prop( this, "elements" );
	return elements ? jQuery.makeArray( elements ) : this;
} ).filter( function() {
	var type = this.type;
9095
	// Use .is( ":disabled" ) so that fieldset[disabled] works
	return this.name && !jQuery( this ).is( ":disabled" ) &&
		rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
		( this.checked || !rcheckableType.test( type ) );
} ).map( function( _i, elem ) {
	var val = jQuery( this ).val();
9102
	if ( val == null ) {
		return null;
	}
9106
	if ( Array.isArray( val ) ) {
		return jQuery.map( val, function( val ) {
			return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
		} );
	}
9112
	return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
} ).get();
}
9116} );
9117
9118
9119var
r20 = /%20/g,
rhash = /#.*$/,
rantiCache = /([?&])_=[^&]*/,
rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
9124
// trac-7653, trac-8125, trac-8152: local protocol detection
rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
rnoContent = /^(?:GET|HEAD)$/,
rprotocol = /^\/\//,
9129
/* Prefilters
* 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
* 2) These are called:
*    - BEFORE asking for a transport
*    - AFTER param serialization (s.data is a string if s.processData is true)
* 3) key is the dataType
* 4) the catchall symbol "*" can be used
* 5) execution will start with transport dataType and THEN continue down to "*" if needed
*/
prefilters = {},
9140
/* Transports bindings
* 1) key is the dataType
* 2) the catchall symbol "*" can be used
* 3) selection will start with transport dataType and THEN go to "*" if needed
*/
transports = {},
9147
// Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression
allTypes = "*/".concat( "*" ),
9150
// Anchor tag for parsing the document origin
originAnchor = document.createElement( "a" );
9153
9154originAnchor.href = location.href;
9155
9156// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
9157function addToPrefiltersOrTransports( structure ) {
9158
// dataTypeExpression is optional and defaults to "*"
return function( dataTypeExpression, func ) {
9161
if ( typeof dataTypeExpression !== "string" ) {
	func = dataTypeExpression;
	dataTypeExpression = "*";
}
9166
var dataType,
	i = 0,
	dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
9170
if ( isFunction( func ) ) {
9172
	// For each dataType in the dataTypeExpression
	while ( ( dataType = dataTypes[ i++ ] ) ) {
9175
		// Prepend if requested
		if ( dataType[ 0 ] === "+" ) {
			dataType = dataType.slice( 1 ) || "*";
			( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
9180
		// Otherwise append
		} else {
			( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
		}
	}
}
};
9188}
9189
9190// Base inspection function for prefilters and transports
9191function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
9192
var inspected = {},
seekingTransport = ( structure === transports );
9195
function inspect( dataType ) {
var selected;
inspected[ dataType ] = true;
jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
	var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
	if ( typeof dataTypeOrTransport === "string" &&
		!seekingTransport && !inspected[ dataTypeOrTransport ] ) {
9203
		options.dataTypes.unshift( dataTypeOrTransport );
		inspect( dataTypeOrTransport );
		return false;
	} else if ( seekingTransport ) {
		return !( selected = dataTypeOrTransport );
	}
} );
return selected;
}
9213
return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
9215}
9216
9217// A special extend for ajax options
9218// that takes "flat" options (not to be deep extended)
9219// Fixes trac-9887
9220function ajaxExtend( target, src ) {
var key, deep,
flatOptions = jQuery.ajaxSettings.flatOptions || {};
9223
for ( key in src ) {
if ( src[ key ] !== undefined ) {
	( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
}
}
if ( deep ) {
jQuery.extend( true, target, deep );
}
9232
return target;
9234}
9235
9236/* Handles responses to an ajax request:
* - finds the right dataType (mediates between content-type and expected dataType)
* - returns the corresponding response
*/
9240function ajaxHandleResponses( s, jqXHR, responses ) {
9241
var ct, type, finalDataType, firstDataType,
contents = s.contents,
dataTypes = s.dataTypes;
9245
// Remove auto dataType and get content-type in the process
while ( dataTypes[ 0 ] === "*" ) {
dataTypes.shift();
if ( ct === undefined ) {
	ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
}
}
9253
// Check if we're dealing with a known content-type
if ( ct ) {
for ( type in contents ) {
	if ( contents[ type ] && contents[ type ].test( ct ) ) {
		dataTypes.unshift( type );
		break;
	}
}
}
9263
// Check to see if we have a response for the expected dataType
if ( dataTypes[ 0 ] in responses ) {
finalDataType = dataTypes[ 0 ];
} else {
9268
// Try convertible dataTypes
for ( type in responses ) {
	if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
		finalDataType = type;
		break;
	}
	if ( !firstDataType ) {
		firstDataType = type;
	}
}
9279
// Or just use first one
finalDataType = finalDataType || firstDataType;
}
9283
// If we found a dataType
// We add the dataType to the list if needed
// and return the corresponding response
if ( finalDataType ) {
if ( finalDataType !== dataTypes[ 0 ] ) {
	dataTypes.unshift( finalDataType );
}
return responses[ finalDataType ];
}
9293}
9294
9295/* Chain conversions given the request and the original response
* Also sets the responseXXX fields on the jqXHR instance
*/
9298function ajaxConvert( s, response, jqXHR, isSuccess ) {
var conv2, current, conv, tmp, prev,
converters = {},
9301
// Work with a copy of dataTypes in case we need to modify it for conversion
dataTypes = s.dataTypes.slice();
9304
// Create converters map with lowercased keys
if ( dataTypes[ 1 ] ) {
for ( conv in s.converters ) {
	converters[ conv.toLowerCase() ] = s.converters[ conv ];
}
}
9311
current = dataTypes.shift();
9313
// Convert to each sequential dataType
while ( current ) {
9316
if ( s.responseFields[ current ] ) {
	jqXHR[ s.responseFields[ current ] ] = response;
}
9320
// Apply the dataFilter if provided
if ( !prev && isSuccess && s.dataFilter ) {
	response = s.dataFilter( response, s.dataType );
}
9325
prev = current;
current = dataTypes.shift();
9328
if ( current ) {
9330
	// There's only work to do if current dataType is non-auto
	if ( current === "*" ) {
9333
		current = prev;
9335
	// Convert response if prev dataType is non-auto and differs from current
	} else if ( prev !== "*" && prev !== current ) {
9338
		// Seek a direct converter
		conv = converters[ prev + " " + current ] || converters[ "* " + current ];
9341
		// If none found, seek a pair
		if ( !conv ) {
			for ( conv2 in converters ) {
9345
				// If conv2 outputs current
				tmp = conv2.split( " " );
				if ( tmp[ 1 ] === current ) {
9349
					// If prev can be converted to accepted input
					conv = converters[ prev + " " + tmp[ 0 ] ] ||
						converters[ "* " + tmp[ 0 ] ];
					if ( conv ) {
9354
						// Condense equivalence converters
						if ( conv === true ) {
							conv = converters[ conv2 ];
9358
						// Otherwise, insert the intermediate dataType
						} else if ( converters[ conv2 ] !== true ) {
							current = tmp[ 0 ];
							dataTypes.unshift( tmp[ 1 ] );
						}
						break;
					}
				}
			}
		}
9369
		// Apply converter (if not an equivalence)
		if ( conv !== true ) {
9372
			// Unless errors are allowed to bubble, catch and return them
			if ( conv && s.throws ) {
				response = conv( response );
			} else {
				try {
					response = conv( response );
				} catch ( e ) {
					return {
						state: "parsererror",
						error: conv ? e : "No conversion from " + prev + " to " + current
					};
				}
			}
		}
	}
}
}
9390
return { state: "success", data: response };
9392}
9393
9394jQuery.extend( {
9395
// Counter for holding the number of active queries
active: 0,
9398
// Last-Modified header cache for next request
lastModified: {},
etag: {},
9402
ajaxSettings: {
url: location.href,
type: "GET",
isLocal: rlocalProtocol.test( location.protocol ),
global: true,
processData: true,
async: true,
contentType: "application/x-www-form-urlencoded; charset=UTF-8",
9411
/*
timeout: 0,
data: null,
dataType: null,
username: null,
password: null,
cache: null,
throws: false,
traditional: false,
headers: {},
*/
9423
accepts: {
	"*": allTypes,
	text: "text/plain",
	html: "text/html",
	xml: "application/xml, text/xml",
	json: "application/json, text/javascript"
},
9431
contents: {
	xml: /\bxml\b/,
	html: /\bhtml/,
	json: /\bjson\b/
},
9437
responseFields: {
	xml: "responseXML",
	text: "responseText",
	json: "responseJSON"
},
9443
// Data converters
// Keys separate source (or catchall "*") and destination types with a single space
converters: {
9447
	// Convert anything to text
	"* text": String,
9450
	// Text to html (true = no transformation)
	"text html": true,
9453
	// Evaluate text as a json expression
	"text json": JSON.parse,
9456
	// Parse text as xml
	"text xml": jQuery.parseXML
},
9460
// For options that shouldn't be deep extended:
// you can add your own custom options here if
// and when you create one that shouldn't be
// deep extended (see ajaxExtend)
flatOptions: {
	url: true,
	context: true
}
},
9470
// Creates a full fledged settings object into target
// with both ajaxSettings and settings fields.
// If target is omitted, writes into ajaxSettings.
ajaxSetup: function( target, settings ) {
return settings ?
9476
	// Building a settings object
	ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
9479
	// Extending ajaxSettings
	ajaxExtend( jQuery.ajaxSettings, target );
},
9483
ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
ajaxTransport: addToPrefiltersOrTransports( transports ),
9486
// Main method
ajax: function( url, options ) {
9489
// If url is an object, simulate pre-1.5 signature
if ( typeof url === "object" ) {
	options = url;
	url = undefined;
}
9495
// Force options to be an object
options = options || {};
9498
var transport,
9500
	// URL without anti-cache param
	cacheURL,
9503
	// Response headers
	responseHeadersString,
	responseHeaders,
9507
	// timeout handle
	timeoutTimer,
9510
	// Url cleanup var
	urlAnchor,
9513
	// Request state (becomes false upon send and true upon completion)
	completed,
9516
	// To know if global events are to be dispatched
	fireGlobals,
9519
	// Loop variable
	i,
9522
	// uncached part of the url
	uncached,
9525
	// Create the final options object
	s = jQuery.ajaxSetup( {}, options ),
9528
	// Callbacks context
	callbackContext = s.context || s,
9531
	// Context for global events is callbackContext if it is a DOM node or jQuery collection
	globalEventContext = s.context &&
		( callbackContext.nodeType || callbackContext.jquery ) ?
		jQuery( callbackContext ) :
		jQuery.event,
9537
	// Deferreds
	deferred = jQuery.Deferred(),
	completeDeferred = jQuery.Callbacks( "once memory" ),
9541
	// Status-dependent callbacks
	statusCode = s.statusCode || {},
9544
	// Headers (they are sent all at once)
	requestHeaders = {},
	requestHeadersNames = {},
9548
	// Default abort message
	strAbort = "canceled",
9551
	// Fake xhr
	jqXHR = {
		readyState: 0,
9555
		// Builds headers hashtable if needed
		getResponseHeader: function( key ) {
			var match;
			if ( completed ) {
				if ( !responseHeaders ) {
					responseHeaders = {};
					while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
						responseHeaders[ match[ 1 ].toLowerCase() + " " ] =
							( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] )
								.concat( match[ 2 ] );
					}
				}
				match = responseHeaders[ key.toLowerCase() + " " ];
			}
			return match == null ? null : match.join( ", " );
		},
9572
		// Raw string
		getAllResponseHeaders: function() {
			return completed ? responseHeadersString : null;
		},
9577
		// Caches the header
		setRequestHeader: function( name, value ) {
			if ( completed == null ) {
				name = requestHeadersNames[ name.toLowerCase() ] =
					requestHeadersNames[ name.toLowerCase() ] || name;
				requestHeaders[ name ] = value;
			}
			return this;
		},
9587
		// Overrides response content-type header
		overrideMimeType: function( type ) {
			if ( completed == null ) {
				s.mimeType = type;
			}
			return this;
		},
9595
		// Status-dependent callbacks
		statusCode: function( map ) {
			var code;
			if ( map ) {
				if ( completed ) {
9601
					// Execute the appropriate callbacks
					jqXHR.always( map[ jqXHR.status ] );
				} else {
9605
					// Lazy-add the new callbacks in a way that preserves old ones
					for ( code in map ) {
						statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
					}
				}
			}
			return this;
		},
9614
		// Cancel the request
		abort: function( statusText ) {
			var finalText = statusText || strAbort;
			if ( transport ) {
				transport.abort( finalText );
			}
			done( 0, finalText );
			return this;
		}
	};
9625
// Attach deferreds
deferred.promise( jqXHR );
9628
// Add protocol if not provided (prefilters might expect it)
// Handle falsy url in the settings object (trac-10093: consistency with old signature)
// We also use the url parameter if available
s.url = ( ( url || s.url || location.href ) + "" )
	.replace( rprotocol, location.protocol + "//" );
9634
// Alias method option to type as per ticket trac-12004
s.type = options.method || options.type || s.method || s.type;
9637
// Extract dataTypes list
s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
9640
// A cross-domain request is in order when the origin doesn't match the current origin.
if ( s.crossDomain == null ) {
	urlAnchor = document.createElement( "a" );
9644
	// Support: IE <=8 - 11, Edge 12 - 15
	// IE throws exception on accessing the href property if url is malformed,
	// e.g. http://example.com:80x/
	try {
		urlAnchor.href = s.url;
9650
		// Support: IE <=8 - 11 only
		// Anchor's host property isn't correctly set when s.url is relative
		urlAnchor.href = urlAnchor.href;
		s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
			urlAnchor.protocol + "//" + urlAnchor.host;
	} catch ( e ) {
9657
		// If there is an error parsing the URL, assume it is crossDomain,
		// it can be rejected by the transport if it is invalid
		s.crossDomain = true;
	}
}
9663
// Convert data if not already a string
if ( s.data && s.processData && typeof s.data !== "string" ) {
	s.data = jQuery.param( s.data, s.traditional );
}
9668
// Apply prefilters
inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
9671
// If request was aborted inside a prefilter, stop there
if ( completed ) {
	return jqXHR;
}
9676
// We can fire global events as of now if asked to
// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (trac-15118)
fireGlobals = jQuery.event && s.global;
9680
// Watch for a new set of requests
if ( fireGlobals && jQuery.active++ === 0 ) {
	jQuery.event.trigger( "ajaxStart" );
}
9685
// Uppercase the type
s.type = s.type.toUpperCase();
9688
// Determine if request has content
s.hasContent = !rnoContent.test( s.type );
9691
// Save the URL in case we're toying with the If-Modified-Since
// and/or If-None-Match header later on
// Remove hash to simplify url manipulation
cacheURL = s.url.replace( rhash, "" );
9696
// More options handling for requests with no content
if ( !s.hasContent ) {
9699
	// Remember the hash so we can put it back
	uncached = s.url.slice( cacheURL.length );
9702
	// If data is available and should be processed, append data to url
	if ( s.data && ( s.processData || typeof s.data === "string" ) ) {
		cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
9706
		// trac-9682: remove data so that it's not used in an eventual retry
		delete s.data;
	}
9710
	// Add or update anti-cache param if needed
	if ( s.cache === false ) {
		cacheURL = cacheURL.replace( rantiCache, "$1" );
		uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) +
			uncached;
	}
9717
	// Put hash and anti-cache on the URL that will be requested (gh-1732)
	s.url = cacheURL + uncached;
9720
// Change '%20' to '+' if this is encoded form body content (gh-2658)
} else if ( s.data && s.processData &&
	( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
	s.data = s.data.replace( r20, "+" );
}
9726
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
if ( s.ifModified ) {
	if ( jQuery.lastModified[ cacheURL ] ) {
		jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
	}
	if ( jQuery.etag[ cacheURL ] ) {
		jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
	}
}
9736
// Set the correct header, if data is being sent
if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
	jqXHR.setRequestHeader( "Content-Type", s.contentType );
}
9741
// Set the Accepts header for the server, depending on the dataType
jqXHR.setRequestHeader(
	"Accept",
	s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
		s.accepts[ s.dataTypes[ 0 ] ] +
			( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
		s.accepts[ "*" ]
);
9750
// Check for headers option
for ( i in s.headers ) {
	jqXHR.setRequestHeader( i, s.headers[ i ] );
}
9755
// Allow custom headers/mimetypes and early abort
if ( s.beforeSend &&
	( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
9759
	// Abort if not done already and return
	return jqXHR.abort();
}
9763
// Aborting is no longer a cancellation
strAbort = "abort";
9766
// Install callbacks on deferreds
completeDeferred.add( s.complete );
jqXHR.done( s.success );
jqXHR.fail( s.error );
9771
// Get transport
transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
9774
// If no transport, we auto-abort
if ( !transport ) {
	done( -1, "No Transport" );
} else {
	jqXHR.readyState = 1;
9780
	// Send global event
	if ( fireGlobals ) {
		globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
	}
9785
	// If request was aborted inside ajaxSend, stop there
	if ( completed ) {
		return jqXHR;
	}
9790
	// Timeout
	if ( s.async && s.timeout > 0 ) {
		timeoutTimer = window.setTimeout( function() {
			jqXHR.abort( "timeout" );
		}, s.timeout );
	}
9797
	try {
		completed = false;
		transport.send( requestHeaders, done );
	} catch ( e ) {
9802
		// Rethrow post-completion exceptions
		if ( completed ) {
			throw e;
		}
9807
		// Propagate others as results
		done( -1, e );
	}
}
9812
// Callback for when everything is done
function done( status, nativeStatusText, responses, headers ) {
	var isSuccess, success, error, response, modified,
		statusText = nativeStatusText;
9817
	// Ignore repeat invocations
	if ( completed ) {
		return;
	}
9822
	completed = true;
9824
	// Clear timeout if it exists
	if ( timeoutTimer ) {
		window.clearTimeout( timeoutTimer );
	}
9829
	// Dereference transport for early garbage collection
	// (no matter how long the jqXHR object will be used)
	transport = undefined;
9833
	// Cache response headers
	responseHeadersString = headers || "";
9836
	// Set readyState
	jqXHR.readyState = status > 0 ? 4 : 0;
9839
	// Determine if successful
	isSuccess = status >= 200 && status < 300 || status === 304;
9842
	// Get response data
	if ( responses ) {
		response = ajaxHandleResponses( s, jqXHR, responses );
	}
9847
	// Use a noop converter for missing script but not if jsonp
	if ( !isSuccess &&
		jQuery.inArray( "script", s.dataTypes ) > -1 &&
		jQuery.inArray( "json", s.dataTypes ) < 0 ) {
		s.converters[ "text script" ] = function() {};
	}
9854
	// Convert no matter what (that way responseXXX fields are always set)
	response = ajaxConvert( s, response, jqXHR, isSuccess );
9857
	// If successful, handle type chaining
	if ( isSuccess ) {
9860
		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
		if ( s.ifModified ) {
			modified = jqXHR.getResponseHeader( "Last-Modified" );
			if ( modified ) {
				jQuery.lastModified[ cacheURL ] = modified;
			}
			modified = jqXHR.getResponseHeader( "etag" );
			if ( modified ) {
				jQuery.etag[ cacheURL ] = modified;
			}
		}
9872
		// if no content
		if ( status === 204 || s.type === "HEAD" ) {
			statusText = "nocontent";
9876
		// if not modified
		} else if ( status === 304 ) {
			statusText = "notmodified";
9880
		// If we have data, let's convert it
		} else {
			statusText = response.state;
			success = response.data;
			error = response.error;
			isSuccess = !error;
		}
	} else {
9889
		// Extract error from statusText and normalize for non-aborts
		error = statusText;
		if ( status || !statusText ) {
			statusText = "error";
			if ( status < 0 ) {
				status = 0;
			}
		}
	}
9899
	// Set data for the fake xhr object
	jqXHR.status = status;
	jqXHR.statusText = ( nativeStatusText || statusText ) + "";
9903
	// Success/Error
	if ( isSuccess ) {
		deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
	} else {
		deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
	}
9910
	// Status-dependent callbacks
	jqXHR.statusCode( statusCode );
	statusCode = undefined;
9914
	if ( fireGlobals ) {
		globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
			[ jqXHR, s, isSuccess ? success : error ] );
	}
9919
	// Complete
	completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
9922
	if ( fireGlobals ) {
		globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
9925
		// Handle the global AJAX counter
		if ( !( --jQuery.active ) ) {
			jQuery.event.trigger( "ajaxStop" );
		}
	}
}
9932
return jqXHR;
},
9935
getJSON: function( url, data, callback ) {
return jQuery.get( url, data, callback, "json" );
},
9939
getScript: function( url, callback ) {
return jQuery.get( url, undefined, callback, "script" );
}
9943} );
9944
9945jQuery.each( [ "get", "post" ], function( _i, method ) {
jQuery[ method ] = function( url, data, callback, type ) {
9947
// Shift arguments if data argument was omitted
if ( isFunction( data ) ) {
	type = type || callback;
	callback = data;
	data = undefined;
}
9954
// The url can be an options object (which then must have .url)
return jQuery.ajax( jQuery.extend( {
	url: url,
	type: method,
	dataType: type,
	data: data,
	success: callback
}, jQuery.isPlainObject( url ) && url ) );
};
9964} );
9965
9966jQuery.ajaxPrefilter( function( s ) {
var i;
for ( i in s.headers ) {
if ( i.toLowerCase() === "content-type" ) {
	s.contentType = s.headers[ i ] || "";
}
}
9973} );
9974
9975
9976jQuery._evalUrl = function( url, options, doc ) {
return jQuery.ajax( {
url: url,
9979
// Make this explicit, since user can override this through ajaxSetup (trac-11264)
type: "GET",
dataType: "script",
cache: true,
async: false,
global: false,
9986
// Only evaluate the response if it is successful (gh-4126)
// dataFilter is not invoked for failure responses, so using it instead
// of the default converter is kludgy but it works.
converters: {
	"text script": function() {}
},
dataFilter: function( response ) {
	jQuery.globalEval( response, options, doc );
}
} );
9997};
9998
9999
10000jQuery.fn.extend( {
wrapAll: function( html ) {
var wrap;
10003
if ( this[ 0 ] ) {
	if ( isFunction( html ) ) {
		html = html.call( this[ 0 ] );
	}
10008
	// The elements to wrap the target around
	wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
10011
	if ( this[ 0 ].parentNode ) {
		wrap.insertBefore( this[ 0 ] );
	}
10015
	wrap.map( function() {
		var elem = this;
10018
		while ( elem.firstElementChild ) {
			elem = elem.firstElementChild;
		}
10022
		return elem;
	} ).append( this );
}
10026
return this;
},
10029
wrapInner: function( html ) {
if ( isFunction( html ) ) {
	return this.each( function( i ) {
		jQuery( this ).wrapInner( html.call( this, i ) );
	} );
}
10036
return this.each( function() {
	var self = jQuery( this ),
		contents = self.contents();
10040
	if ( contents.length ) {
		contents.wrapAll( html );
10043
	} else {
		self.append( html );
	}
} );
},
10049
wrap: function( html ) {
var htmlIsFunction = isFunction( html );
10052
return this.each( function( i ) {
	jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );
} );
},
10057
unwrap: function( selector ) {
this.parent( selector ).not( "body" ).each( function() {
	jQuery( this ).replaceWith( this.childNodes );
} );
return this;
}
10064} );
10065
10066
10067jQuery.expr.pseudos.hidden = function( elem ) {
return !jQuery.expr.pseudos.visible( elem );
10069};
10070jQuery.expr.pseudos.visible = function( elem ) {
return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
10072};
10073
10074
10075
10076
10077jQuery.ajaxSettings.xhr = function() {
try {
return new window.XMLHttpRequest();
} catch ( e ) {}
10081};
10082
10083var xhrSuccessStatus = {
10084
// File protocol always yields status code 0, assume 200
0: 200,
10087
// Support: IE <=9 only
// trac-1450: sometimes IE returns 1223 when it should be 204
1223: 204
},
xhrSupported = jQuery.ajaxSettings.xhr();
10093
10094support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
10095support.ajax = xhrSupported = !!xhrSupported;
10096
10097jQuery.ajaxTransport( function( options ) {
var callback, errorCallback;
10099
// Cross domain only allowed if supported through XMLHttpRequest
if ( support.cors || xhrSupported && !options.crossDomain ) {
return {
	send: function( headers, complete ) {
		var i,
			xhr = options.xhr();
10106
		xhr.open(
			options.type,
			options.url,
			options.async,
			options.username,
			options.password
		);
10114
		// Apply custom fields if provided
		if ( options.xhrFields ) {
			for ( i in options.xhrFields ) {
				xhr[ i ] = options.xhrFields[ i ];
			}
		}
10121
		// Override mime type if needed
		if ( options.mimeType && xhr.overrideMimeType ) {
			xhr.overrideMimeType( options.mimeType );
		}
10126
		// X-Requested-With header
		// For cross-domain requests, seeing as conditions for a preflight are
		// akin to a jigsaw puzzle, we simply never set it to be sure.
		// (it can always be set on a per-request basis or even using ajaxSetup)
		// For same-domain requests, won't change header if already provided.
		if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
			headers[ "X-Requested-With" ] = "XMLHttpRequest";
		}
10135
		// Set headers
		for ( i in headers ) {
			xhr.setRequestHeader( i, headers[ i ] );
		}
10140
		// Callback
		callback = function( type ) {
			return function() {
				if ( callback ) {
					callback = errorCallback = xhr.onload =
						xhr.onerror = xhr.onabort = xhr.ontimeout =
							xhr.onreadystatechange = null;
10148
					if ( type === "abort" ) {
						xhr.abort();
					} else if ( type === "error" ) {
10152
						// Support: IE <=9 only
						// On a manual native abort, IE9 throws
						// errors on any property access that is not readyState
						if ( typeof xhr.status !== "number" ) {
							complete( 0, "error" );
						} else {
							complete(
10160
								// File: protocol always yields status 0; see trac-8605, trac-14207
								xhr.status,
								xhr.statusText
							);
						}
					} else {
						complete(
							xhrSuccessStatus[ xhr.status ] || xhr.status,
							xhr.statusText,
10170
							// Support: IE <=9 only
							// IE9 has no XHR2 but throws on binary (trac-11426)
							// For XHR2 non-text, let the caller handle it (gh-2498)
							( xhr.responseType || "text" ) !== "text"  ||
							typeof xhr.responseText !== "string" ?
								{ binary: xhr.response } :
								{ text: xhr.responseText },
							xhr.getAllResponseHeaders()
						);
					}
				}
			};
		};
10184
		// Listen to events
		xhr.onload = callback();
		errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" );
10188
		// Support: IE 9 only
		// Use onreadystatechange to replace onabort
		// to handle uncaught aborts
		if ( xhr.onabort !== undefined ) {
			xhr.onabort = errorCallback;
		} else {
			xhr.onreadystatechange = function() {
10196
				// Check readyState before timeout as it changes
				if ( xhr.readyState === 4 ) {
10199
					// Allow onerror to be called first,
					// but that will not handle a native abort
					// Also, save errorCallback to a variable
					// as xhr.onerror cannot be accessed
					window.setTimeout( function() {
						if ( callback ) {
							errorCallback();
						}
					} );
				}
			};
		}
10212
		// Create the abort callback
		callback = callback( "abort" );
10215
		try {
10217
			// Do send the request (this may raise an exception)
			xhr.send( options.hasContent && options.data || null );
		} catch ( e ) {
10221
			// trac-14683: Only rethrow if this hasn't been notified as an error yet
			if ( callback ) {
				throw e;
			}
		}
	},
10228
	abort: function() {
		if ( callback ) {
			callback();
		}
	}
};
}
10236} );
10237
10238
10239
10240
10241// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
10242jQuery.ajaxPrefilter( function( s ) {
if ( s.crossDomain ) {
s.contents.script = false;
}
10246} );
10247
10248// Install script dataType
10249jQuery.ajaxSetup( {
accepts: {
script: "text/javascript, application/javascript, " +
	"application/ecmascript, application/x-ecmascript"
},
contents: {
script: /\b(?:java|ecma)script\b/
},
converters: {
"text script": function( text ) {
	jQuery.globalEval( text );
	return text;
}
}
10263} );
10264
10265// Handle cache's special case and crossDomain
10266jQuery.ajaxPrefilter( "script", function( s ) {
if ( s.cache === undefined ) {
s.cache = false;
}
if ( s.crossDomain ) {
s.type = "GET";
}
10273} );
10274
10275// Bind script tag hack transport
10276jQuery.ajaxTransport( "script", function( s ) {
10277
// This transport only deals with cross domain or forced-by-attrs requests
if ( s.crossDomain || s.scriptAttrs ) {
var script, callback;
return {
	send: function( _, complete ) {
		script = jQuery( "<script>" )
			.attr( s.scriptAttrs || {} )
			.prop( { charset: s.scriptCharset, src: s.url } )
			.on( "load error", callback = function( evt ) {
				script.remove();
				callback = null;
				if ( evt ) {
					complete( evt.type === "error" ? 404 : 200, evt.type );
				}
			} );
10293
		// Use native DOM manipulation to avoid our domManip AJAX trickery
		document.head.appendChild( script[ 0 ] );
	},
	abort: function() {
		if ( callback ) {
			callback();
		}
	}
};
}
10304} );
10305
10306
10307
10308
10309var oldCallbacks = [],
rjsonp = /(=)\?(?=&|$)|\?\?/;
10311
10312// Default jsonp settings
10313jQuery.ajaxSetup( {
jsonp: "callback",
jsonpCallback: function() {
var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce.guid++ ) );
this[ callback ] = true;
return callback;
}
10320} );
10321
10322// Detect, normalize options and install callbacks for jsonp requests
10323jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
10324
var callbackName, overwritten, responseContainer,
jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
	"url" :
	typeof s.data === "string" &&
		( s.contentType || "" )
			.indexOf( "application/x-www-form-urlencoded" ) === 0 &&
		rjsonp.test( s.data ) && "data"
);
10333
// Handle iff the expected data type is "jsonp" or we have a parameter to set
if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
10336
// Get callback name, remembering preexisting value associated with it
callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?
	s.jsonpCallback() :
	s.jsonpCallback;
10341
// Insert callback into url or form data
if ( jsonProp ) {
	s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
} else if ( s.jsonp !== false ) {
	s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
}
10348
// Use data converter to retrieve json after script execution
s.converters[ "script json" ] = function() {
	if ( !responseContainer ) {
		jQuery.error( callbackName + " was not called" );
	}
	return responseContainer[ 0 ];
};
10356
// Force json dataType
s.dataTypes[ 0 ] = "json";
10359
// Install callback
overwritten = window[ callbackName ];
window[ callbackName ] = function() {
	responseContainer = arguments;
};
10365
// Clean-up function (fires after converters)
jqXHR.always( function() {
10368
	// If previous value didn't exist - remove it
	if ( overwritten === undefined ) {
		jQuery( window ).removeProp( callbackName );
10372
	// Otherwise restore preexisting value
	} else {
		window[ callbackName ] = overwritten;
	}
10377
	// Save back as free
	if ( s[ callbackName ] ) {
10380
		// Make sure that re-using the options doesn't screw things around
		s.jsonpCallback = originalSettings.jsonpCallback;
10383
		// Save the callback name for future use
		oldCallbacks.push( callbackName );
	}
10387
	// Call if it was a function and we have a response
	if ( responseContainer && isFunction( overwritten ) ) {
		overwritten( responseContainer[ 0 ] );
	}
10392
	responseContainer = overwritten = undefined;
} );
10395
// Delegate to script
return "script";
}
10399} );
10400
10401
10402
10403
10404// Support: Safari 8 only
10405// In Safari 8 documents created via document.implementation.createHTMLDocument
10406// collapse sibling forms: the second one becomes a child of the first one.
10407// Because of that, this security measure has to be disabled in Safari 8.
10408// https://bugs.webkit.org/show_bug.cgi?id=137337
10409support.createHTMLDocument = ( function() {
var body = document.implementation.createHTMLDocument( "" ).body;
body.innerHTML = "<form></form><form></form>";
return body.childNodes.length === 2;
10413} )();
10414
10415
10416// Argument "data" should be string of html
10417// context (optional): If specified, the fragment will be created in this context,
10418// defaults to document
10419// keepScripts (optional): If true, will include scripts passed in the html string
10420jQuery.parseHTML = function( data, context, keepScripts ) {
if ( typeof data !== "string" ) {
return [];
}
if ( typeof context === "boolean" ) {
keepScripts = context;
context = false;
}
10428
var base, parsed, scripts;
10430
if ( !context ) {
10432
// Stop scripts or inline event handlers from being executed immediately
// by using document.implementation
if ( support.createHTMLDocument ) {
	context = document.implementation.createHTMLDocument( "" );
10437
	// Set the base href for the created document
	// so any parsed elements with URLs
	// are based on the document's URL (gh-2965)
	base = context.createElement( "base" );
	base.href = document.location.href;
	context.head.appendChild( base );
} else {
	context = document;
}
}
10448
parsed = rsingleTag.exec( data );
scripts = !keepScripts && [];
10451
// Single tag
if ( parsed ) {
return [ context.createElement( parsed[ 1 ] ) ];
}
10456
parsed = buildFragment( [ data ], context, scripts );
10458
if ( scripts && scripts.length ) {
jQuery( scripts ).remove();
}
10462
return jQuery.merge( [], parsed.childNodes );
10464};
10465
10466
10467/**
* Load a url into a page
*/
10470jQuery.fn.load = function( url, params, callback ) {
var selector, type, response,
self = this,
off = url.indexOf( " " );
10474
if ( off > -1 ) {
selector = stripAndCollapse( url.slice( off ) );
url = url.slice( 0, off );
}
10479
// If it's a function
if ( isFunction( params ) ) {
10482
// We assume that it's the callback
callback = params;
params = undefined;
10486
// Otherwise, build a param string
} else if ( params && typeof params === "object" ) {
type = "POST";
}
10491
// If we have elements to modify, make the request
if ( self.length > 0 ) {
jQuery.ajax( {
	url: url,
10496
	// If "type" variable is undefined, then "GET" method will be used.
	// Make value of this field explicit since
	// user can override it through ajaxSetup method
	type: type || "GET",
	dataType: "html",
	data: params
} ).done( function( responseText ) {
10504
	// Save response for use in complete callback
	response = arguments;
10507
	self.html( selector ?
10509
		// If a selector was specified, locate the right elements in a dummy div
		// Exclude scripts to avoid IE 'Permission Denied' errors
		jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
10513
		// Otherwise use the full result
		responseText );
10516
// If the request succeeds, this function gets "data", "status", "jqXHR"
// but they are ignored because response was set above.
// If it fails, this function gets "jqXHR", "status", "error"
} ).always( callback && function( jqXHR, status ) {
	self.each( function() {
		callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
	} );
} );
}
10526
return this;
10528};
10529
10530
10531
10532
10533jQuery.expr.pseudos.animated = function( elem ) {
return jQuery.grep( jQuery.timers, function( fn ) {
return elem === fn.elem;
} ).length;
10537};
10538
10539
10540
10541
10542jQuery.offset = {
setOffset: function( elem, options, i ) {
var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
	position = jQuery.css( elem, "position" ),
	curElem = jQuery( elem ),
	props = {};
10548
// Set position first, in-case top/left are set even on static elem
if ( position === "static" ) {
	elem.style.position = "relative";
}
10553
curOffset = curElem.offset();
curCSSTop = jQuery.css( elem, "top" );
curCSSLeft = jQuery.css( elem, "left" );
calculatePosition = ( position === "absolute" || position === "fixed" ) &&
	( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;
10559
// Need to be able to calculate position if either
// top or left is auto and position is either absolute or fixed
if ( calculatePosition ) {
	curPosition = curElem.position();
	curTop = curPosition.top;
	curLeft = curPosition.left;
10566
} else {
	curTop = parseFloat( curCSSTop ) || 0;
	curLeft = parseFloat( curCSSLeft ) || 0;
}
10571
if ( isFunction( options ) ) {
10573
	// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
	options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
}
10577
if ( options.top != null ) {
	props.top = ( options.top - curOffset.top ) + curTop;
}
if ( options.left != null ) {
	props.left = ( options.left - curOffset.left ) + curLeft;
}
10584
if ( "using" in options ) {
	options.using.call( elem, props );
10587
} else {
	curElem.css( props );
}
}
10592};
10593
10594jQuery.fn.extend( {
10595
// offset() relates an element's border box to the document origin
offset: function( options ) {
10598
// Preserve chaining for setter
if ( arguments.length ) {
	return options === undefined ?
		this :
		this.each( function( i ) {
			jQuery.offset.setOffset( this, options, i );
		} );
}
10607
var rect, win,
	elem = this[ 0 ];
10610
if ( !elem ) {
	return;
}
10614
// Return zeros for disconnected and hidden (display: none) elements (gh-2310)
// Support: IE <=11 only
// Running getBoundingClientRect on a
// disconnected node in IE throws an error
if ( !elem.getClientRects().length ) {
	return { top: 0, left: 0 };
}
10622
// Get document-relative position by adding viewport scroll to viewport-relative gBCR
rect = elem.getBoundingClientRect();
win = elem.ownerDocument.defaultView;
return {
	top: rect.top + win.pageYOffset,
	left: rect.left + win.pageXOffset
};
},
10631
// position() relates an element's margin box to its offset parent's padding box
// This corresponds to the behavior of CSS absolute positioning
position: function() {
if ( !this[ 0 ] ) {
	return;
}
10638
var offsetParent, offset, doc,
	elem = this[ 0 ],
	parentOffset = { top: 0, left: 0 };
10642
// position:fixed elements are offset from the viewport, which itself always has zero offset
if ( jQuery.css( elem, "position" ) === "fixed" ) {
10645
	// Assume position:fixed implies availability of getBoundingClientRect
	offset = elem.getBoundingClientRect();
10648
} else {
	offset = this.offset();
10651
	// Account for the *real* offset parent, which can be the document or its root element
	// when a statically positioned element is identified
	doc = elem.ownerDocument;
	offsetParent = elem.offsetParent || doc.documentElement;
	while ( offsetParent &&
		( offsetParent === doc.body || offsetParent === doc.documentElement ) &&
		jQuery.css( offsetParent, "position" ) === "static" ) {
10659
		offsetParent = offsetParent.parentNode;
	}
	if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {
10663
		// Incorporate borders into its offset, since they are outside its content origin
		parentOffset = jQuery( offsetParent ).offset();
		parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true );
		parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true );
	}
}
10670
// Subtract parent offsets and element margins
return {
	top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
	left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
};
},
10677
// This method will return documentElement in the following cases:
// 1) For the element inside the iframe without offsetParent, this method will return
//    documentElement of the parent window
// 2) For the hidden or detached element
// 3) For body or html element, i.e. in case of the html node - it will return itself
//
// but those exceptions were never presented as a real life use-cases
// and might be considered as more preferable results.
//
// This logic, however, is not guaranteed and can change at any point in the future
offsetParent: function() {
return this.map( function() {
	var offsetParent = this.offsetParent;
10691
	while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
		offsetParent = offsetParent.offsetParent;
	}
10695
	return offsetParent || documentElement;
} );
}
10699} );
10700
10701// Create scrollLeft and scrollTop methods
10702jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
var top = "pageYOffset" === prop;
10704
jQuery.fn[ method ] = function( val ) {
return access( this, function( elem, method, val ) {
10707
	// Coalesce documents and windows
	var win;
	if ( isWindow( elem ) ) {
		win = elem;
	} else if ( elem.nodeType === 9 ) {
		win = elem.defaultView;
	}
10715
	if ( val === undefined ) {
		return win ? win[ prop ] : elem[ method ];
	}
10719
	if ( win ) {
		win.scrollTo(
			!top ? val : win.pageXOffset,
			top ? val : win.pageYOffset
		);
10725
	} else {
		elem[ method ] = val;
	}
}, method, val, arguments.length );
};
10731} );
10732
10733// Support: Safari <=7 - 9.1, Chrome <=37 - 49
10734// Add the top/left cssHooks using jQuery.fn.position
10735// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
10736// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
10737// getComputedStyle returns percent when specified for top/left/bottom/right;
10738// rather than make the css module depend on the offset module, just check for it here
10739jQuery.each( [ "top", "left" ], function( _i, prop ) {
jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
function( elem, computed ) {
	if ( computed ) {
		computed = curCSS( elem, prop );
10744
		// If curCSS returns percentage, fallback to offset
		return rnumnonpx.test( computed ) ?
			jQuery( elem ).position()[ prop ] + "px" :
			computed;
	}
}
);
10752} );
10753
10754
10755// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
10756jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
jQuery.each( {
padding: "inner" + name,
content: type,
"": "outer" + name
}, function( defaultExtra, funcName ) {
10762
// Margin is only for outerHeight, outerWidth
jQuery.fn[ funcName ] = function( margin, value ) {
	var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
		extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
10767
	return access( this, function( elem, type, value ) {
		var doc;
10770
		if ( isWindow( elem ) ) {
10772
			// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
			return funcName.indexOf( "outer" ) === 0 ?
				elem[ "inner" + name ] :
				elem.document.documentElement[ "client" + name ];
		}
10778
		// Get document width or height
		if ( elem.nodeType === 9 ) {
			doc = elem.documentElement;
10782
			// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
			// whichever is greatest
			return Math.max(
				elem.body[ "scroll" + name ], doc[ "scroll" + name ],
				elem.body[ "offset" + name ], doc[ "offset" + name ],
				doc[ "client" + name ]
			);
		}
10791
		return value === undefined ?
10793
			// Get width or height on the element, requesting but not forcing parseFloat
			jQuery.css( elem, type, extra ) :
10796
			// Set width or height on the element
			jQuery.style( elem, type, value, extra );
	}, type, chainable ? margin : undefined, chainable );
};
} );
10802} );
10803
10804
10805jQuery.each( [
"ajaxStart",
"ajaxStop",
"ajaxComplete",
"ajaxError",
"ajaxSuccess",
"ajaxSend"
10812], function( _i, type ) {
jQuery.fn[ type ] = function( fn ) {
return this.on( type, fn );
};
10816} );
10817
10818
10819
10820
10821jQuery.fn.extend( {
10822
bind: function( types, data, fn ) {
return this.on( types, null, data, fn );
},
unbind: function( types, fn ) {
return this.off( types, null, fn );
},
10829
delegate: function( selector, types, data, fn ) {
return this.on( types, selector, data, fn );
},
undelegate: function( selector, types, fn ) {
10834
// ( namespace ) or ( selector, types [, fn] )
return arguments.length === 1 ?
	this.off( selector, "**" ) :
	this.off( types, selector || "**", fn );
},
10840
hover: function( fnOver, fnOut ) {
return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
}
10844} );
10845
10846jQuery.each(
( "blur focus focusin focusout resize scroll click dblclick " +
"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
"change select submit keydown keypress keyup contextmenu" ).split( " " ),
function( _i, name ) {
10851
// Handle event binding
jQuery.fn[ name ] = function( data, fn ) {
	return arguments.length > 0 ?
		this.on( name, null, data, fn ) :
		this.trigger( name );
};
}
10859);
10860
10861
10862
10863
10864// Support: Android <=4.0 only
10865// Make sure we trim BOM and NBSP
10866// Require that the "whitespace run" starts from a non-whitespace
10867// to avoid O(N^2) behavior when the engine would try matching "\s+$" at each space position.
10868var rtrim = /^[\s\uFEFF\xA0]+|([^\s\uFEFF\xA0])[\s\uFEFF\xA0]+$/g;
10869
10870// Bind a function to a context, optionally partially applying any
10871// arguments.
10872// jQuery.proxy is deprecated to promote standards (specifically Function#bind)
10873// However, it is not slated for removal any time soon
10874jQuery.proxy = function( fn, context ) {
var tmp, args, proxy;
10876
if ( typeof context === "string" ) {
tmp = fn[ context ];
context = fn;
fn = tmp;
}
10882
// Quick check to determine if target is callable, in the spec
// this throws a TypeError, but we will just return undefined.
if ( !isFunction( fn ) ) {
return undefined;
}
10888
// Simulated bind
args = slice.call( arguments, 2 );
proxy = function() {
return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
};
10894
// Set the guid of unique handler to the same of original handler, so it can be removed
proxy.guid = fn.guid = fn.guid || jQuery.guid++;
10897
return proxy;
10899};
10900
10901jQuery.holdReady = function( hold ) {
if ( hold ) {
jQuery.readyWait++;
} else {
jQuery.ready( true );
}
10907};
10908jQuery.isArray = Array.isArray;
10909jQuery.parseJSON = JSON.parse;
10910jQuery.nodeName = nodeName;
10911jQuery.isFunction = isFunction;
10912jQuery.isWindow = isWindow;
10913jQuery.camelCase = camelCase;
10914jQuery.type = toType;
10915
10916jQuery.now = Date.now;
10917
10918jQuery.isNumeric = function( obj ) {
10919
// As of jQuery 3.0, isNumeric is limited to
// strings and numbers (primitives or objects)
// that can be coerced to finite numbers (gh-2662)
var type = jQuery.type( obj );
return ( type === "number" || type === "string" ) &&
10925
// parseFloat NaNs numeric-cast false positives ("")
// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
// subtraction forces infinities to NaN
!isNaN( obj - parseFloat( obj ) );
10930};
10931
10932jQuery.trim = function( text ) {
return text == null ?
"" :
( text + "" ).replace( rtrim, "$1" );
10936};
10937
10938
10939
10940// Register as a named AMD module, since jQuery can be concatenated with other
10941// files that may use define, but not via a proper concatenation script that
10942// understands anonymous AMD modules. A named AMD is safest and most robust
10943// way to register. Lowercase jquery is used because AMD module names are
10944// derived from file names, and jQuery is normally delivered in a lowercase
10945// file name. Do this after creating the global so that if an AMD module wants
10946// to call noConflict to hide this version of jQuery, it will work.
10947
10948// Note that for maximum portability, libraries that are not jQuery should
10949// declare themselves as anonymous modules, and avoid setting a global if an
10950// AMD loader is present. jQuery is a special case. For more information, see
10951// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
10952
10953if ( typeof define === "function" && define.amd ) {
define( "jquery", [], function() {
return jQuery;
} );
10957}
10958
10959
10960
10961
10962var
10963
// Map over jQuery in case of overwrite
_jQuery = window.jQuery,
10966
// Map over the $ in case of overwrite
_$ = window.$;
10969
10970jQuery.noConflict = function( deep ) {
if ( window.$ === jQuery ) {
window.$ = _$;
}
10974
if ( deep && window.jQuery === jQuery ) {
window.jQuery = _jQuery;
}
10978
return jQuery;
10980};
10981
10982// Expose jQuery and $ identifiers, even in AMD
10983// (trac-7102#comment:10, https://github.com/jquery/jquery/pull/557)
10984// and CommonJS for browser emulators (trac-13566)
10985if ( typeof noGlobal === "undefined" ) {
window.jQuery = window.$ = jQuery;
10987}
10988
10989
10990
10991
10992return jQuery;
10993} );
1	`/*!`
2	`* jQuery JavaScript Library v3.6.3`
3	`* https://jquery.com/`
4	`*`
5	`* Includes Sizzle.js`
6	`* https://sizzlejs.com/`
7	`*`
8	`* Copyright OpenJS Foundation and other contributors`
9	`* Released under the MIT license`
10	`* https://jquery.org/license`
11	`*`
12	`* Date: 2022-12-20T21:28Z`
13	`*/`
14	`( function( global, factory ) {`
15
16	`"use strict";`
17
18	`if ( typeof module === "object" && typeof module.exports === "object" ) {`
19
20	// For CommonJS and CommonJS-like environments where a proper `window`
21	`// is present, execute the factory and get jQuery.`
22	// For environments that do not have a `window` with a `document`
23	`// (such as Node.js), expose a factory as module.exports.`
24	// This accentuates the need for the creation of a real `window`.
25	`// e.g. var jQuery = require("jquery")(window);`
26	`// See ticket trac-14549 for more info.`
27	`module.exports = global.document ?`
28	`factory( global, true ) :`
29	`function( w ) {`
30	`if ( !w.document ) {`
31	`throw new Error( "jQuery requires a window with a document" );`
32	`}`
33	`return factory( w );`
34	`};`
35	`} else {`
36	`factory( global );`
37	`}`
38
39	`// Pass this if window is not defined yet`
40	`} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {`