LaravelTest

1
/*!
2
 * jQuery JavaScript Library v3.6.0 -ajax,-ajax/jsonp,-ajax/load,-ajax/script,-ajax/var/location,-ajax/var/nonce,-ajax/var/rquery,-ajax/xhr,-manipulation/_evalUrl,-deprecated/ajax-event-alias,-effects,-effects/Tween,-effects/animatedSelector
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: 2021-03-02T17:08Z
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 #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 ) {
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

48
var arr = [];
49

50
var getProto = Object.getPrototypeOf;
51

52
var slice = arr.slice;
53

54
var flat = arr.flat ? function( array ) {
55
	return arr.flat.call( array );
56
} : function( array ) {
57
	return arr.concat.apply( [], array );
58
};
59

60

61
var push = arr.push;
62

63
var indexOf = arr.indexOf;
64

65
var class2type = {};
66

67
var toString = class2type.toString;
68

69
var hasOwn = class2type.hasOwnProperty;
70

71
var fnToString = hasOwn.toString;
72

73
var ObjectFunctionString = fnToString.call( Object );
74

75
var support = {};
76

77
var isFunction = function isFunction( obj ) {
78

79
		// Support: Chrome <=57, Firefox <=52
80
		// In some browsers, typeof returns "function" for HTML <object> elements
81
		// (i.e., `typeof document.createElement( "object" ) === "function"`).
82
		// We don't want to classify *any* DOM node as a function.
83
		// Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5
84
		// Plus for old WebKit, typeof returns "function" for HTML collections
85
		// (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756)
86
		return typeof obj === "function" && typeof obj.nodeType !== "number" &&
87
			typeof obj.item !== "function";
88
	};
89

90

91
var isWindow = function isWindow( obj ) {
92
		return obj != null && obj === obj.window;
93
	};
94

95

96
var document = window.document;
97

98

99

100
	var preservedScriptAttributes = {
101
		type: true,
102
		src: true,
103
		nonce: true,
104
		noModule: true
105
	};
106

107
	function DOMEval( code, node, doc ) {
108
		doc = doc || document;
109

110
		var i, val,
111
			script = doc.createElement( "script" );
112

113
		script.text = code;
114
		if ( node ) {
115
			for ( i in preservedScriptAttributes ) {
116

117
				// Support: Firefox 64+, Edge 18+
118
				// Some browsers don't support the "nonce" property on scripts.
119
				// On the other hand, just using `getAttribute` is not enough as
120
				// the `nonce` attribute is reset to an empty string whenever it
121
				// becomes browsing-context connected.
122
				// See https://github.com/whatwg/html/issues/2369
123
				// See https://html.spec.whatwg.org/#nonce-attributes
124
				// The `node.getAttribute` check was added for the sake of
125
				// `jQuery.globalEval` so that it can fake a nonce-containing node
126
				// via an object.
127
				val = node[ i ] || node.getAttribute && node.getAttribute( i );
128
				if ( val ) {
129
					script.setAttribute( i, val );
130
				}
131
			}
132
		}
133
		doc.head.appendChild( script ).parentNode.removeChild( script );
134
	}
135

136

137
function toType( obj ) {
138
	if ( obj == null ) {
139
		return obj + "";
140
	}
141

142
	// Support: Android <=2.3 only (functionish RegExp)
143
	return typeof obj === "object" || typeof obj === "function" ?
144
		class2type[ toString.call( obj ) ] || "object" :
145
		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

153
var
154
	version = "3.6.0 -ajax,-ajax/jsonp,-ajax/load,-ajax/script,-ajax/var/location,-ajax/var/nonce,-ajax/var/rquery,-ajax/xhr,-manipulation/_evalUrl,-deprecated/ajax-event-alias,-effects,-effects/Tween,-effects/animatedSelector",
155

156
	// Define a local copy of jQuery
157
	jQuery = function( selector, context ) {
158

159
		// The jQuery object is actually just the init constructor 'enhanced'
160
		// Need init if jQuery is called (just allow error to be thrown if not included)
161
		return new jQuery.fn.init( selector, context );
162
	};
163

164
jQuery.fn = jQuery.prototype = {
165

166
	// The current version of jQuery being used
167
	jquery: version,
168

169
	constructor: jQuery,
170

171
	// The default length of a jQuery object is 0
172
	length: 0,
173

174
	toArray: function() {
175
		return slice.call( this );
176
	},
177

178
	// Get the Nth element in the matched element set OR
179
	// Get the whole matched element set as a clean array
180
	get: function( num ) {
181

182
		// Return all the elements in a clean array
183
		if ( num == null ) {
184
			return slice.call( this );
185
		}
186

187
		// Return just the one element from the set
188
		return num < 0 ? this[ num + this.length ] : this[ num ];
189
	},
190

191
	// Take an array of elements and push it onto the stack
192
	// (returning the new matched element set)
193
	pushStack: function( elems ) {
194

195
		// Build a new jQuery matched element set
196
		var ret = jQuery.merge( this.constructor(), elems );
197

198
		// Add the old object onto the stack (as a reference)
199
		ret.prevObject = this;
200

201
		// Return the newly-formed element set
202
		return ret;
203
	},
204

205
	// Execute a callback for every element in the matched set.
206
	each: function( callback ) {
207
		return jQuery.each( this, callback );
208
	},
209

210
	map: function( callback ) {
211
		return this.pushStack( jQuery.map( this, function( elem, i ) {
212
			return callback.call( elem, i, elem );
213
		} ) );
214
	},
215

216
	slice: function() {
217
		return this.pushStack( slice.apply( this, arguments ) );
218
	},
219

220
	first: function() {
221
		return this.eq( 0 );
222
	},
223

224
	last: function() {
225
		return this.eq( -1 );
226
	},
227

228
	even: function() {
229
		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
230
			return ( i + 1 ) % 2;
231
		} ) );
232
	},
233

234
	odd: function() {
235
		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
236
			return i % 2;
237
		} ) );
238
	},
239

240
	eq: function( i ) {
241
		var len = this.length,
242
			j = +i + ( i < 0 ? len : 0 );
243
		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
244
	},
245

246
	end: function() {
247
		return this.prevObject || this.constructor();
248
	},
249

250
	// For internal use only.
251
	// Behaves like an Array's method, not like a jQuery method.
252
	push: push,
253
	sort: arr.sort,
254
	splice: arr.splice
255
};
256

257
jQuery.extend = jQuery.fn.extend = function() {
258
	var options, name, src, copy, copyIsArray, clone,
259
		target = arguments[ 0 ] || {},
260
		i = 1,
261
		length = arguments.length,
262
		deep = false;
263

264
	// Handle a deep copy situation
265
	if ( typeof target === "boolean" ) {
266
		deep = target;
267

268
		// Skip the boolean and the target
269
		target = arguments[ i ] || {};
270
		i++;
271
	}
272

273
	// Handle case when target is a string or something (possible in deep copy)
274
	if ( typeof target !== "object" && !isFunction( target ) ) {
275
		target = {};
276
	}
277

278
	// Extend jQuery itself if only one argument is passed
279
	if ( i === length ) {
280
		target = this;
281
		i--;
282
	}
283

284
	for ( ; i < length; i++ ) {
285

286
		// Only deal with non-null/undefined values
287
		if ( ( options = arguments[ i ] ) != null ) {
288

289
			// Extend the base object
290
			for ( name in options ) {
291
				copy = options[ name ];
292

293
				// Prevent Object.prototype pollution
294
				// Prevent never-ending loop
295
				if ( name === "__proto__" || target === copy ) {
296
					continue;
297
				}
298

299
				// Recurse if we're merging plain objects or arrays
300
				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
301
					( copyIsArray = Array.isArray( copy ) ) ) ) {
302
					src = target[ name ];
303

304
					// Ensure proper type for the source value
305
					if ( copyIsArray && !Array.isArray( src ) ) {
306
						clone = [];
307
					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
308
						clone = {};
309
					} else {
310
						clone = src;
311
					}
312
					copyIsArray = false;
313

314
					// Never move original objects, clone them
315
					target[ name ] = jQuery.extend( deep, clone, copy );
316

317
				// Don't bring in undefined values
318
				} else if ( copy !== undefined ) {
319
					target[ name ] = copy;
320
				}
321
			}
322
		}
323
	}
324

325
	// Return the modified object
326
	return target;
327
};
328

329
jQuery.extend( {
330

331
	// Unique for each copy of jQuery on the page
332
	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
333

334
	// Assume jQuery is ready without the ready module
335
	isReady: true,
336

337
	error: function( msg ) {
338
		throw new Error( msg );
339
	},
340

341
	noop: function() {},
342

343
	isPlainObject: function( obj ) {
344
		var proto, Ctor;
345

346
		// Detect obvious negatives
347
		// Use toString instead of jQuery.type to catch host objects
348
		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
349
			return false;
350
		}
351

352
		proto = getProto( obj );
353

354
		// Objects with no prototype (e.g., `Object.create( null )`) are plain
355
		if ( !proto ) {
356
			return true;
357
		}
358

359
		// Objects with prototype are plain iff they were constructed by a global Object function
360
		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
361
		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
362
	},
363

364
	isEmptyObject: function( obj ) {
365
		var name;
366

367
		for ( name in obj ) {
368
			return false;
369
		}
370
		return true;
371
	},
372

373
	// Evaluates a script in a provided context; falls back to the global one
374
	// if not specified.
375
	globalEval: function( code, options, doc ) {
376
		DOMEval( code, { nonce: options && options.nonce }, doc );
377
	},
378

379
	each: function( obj, callback ) {
380
		var length, i = 0;
381

382
		if ( isArrayLike( obj ) ) {
383
			length = obj.length;
384
			for ( ; i < length; i++ ) {
385
				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
386
					break;
387
				}
388
			}
389
		} else {
390
			for ( i in obj ) {
391
				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
392
					break;
393
				}
394
			}
395
		}
396

397
		return obj;
398
	},
399

400
	// results is for internal usage only
401
	makeArray: function( arr, results ) {
402
		var ret = results || [];
403

404
		if ( arr != null ) {
405
			if ( isArrayLike( Object( arr ) ) ) {
406
				jQuery.merge( ret,
407
					typeof arr === "string" ?
408
						[ arr ] : arr
409
				);
410
			} else {
411
				push.call( ret, arr );
412
			}
413
		}
414

415
		return ret;
416
	},
417

418
	inArray: function( elem, arr, i ) {
419
		return arr == null ? -1 : indexOf.call( arr, elem, i );
420
	},
421

422
	// Support: Android <=4.0 only, PhantomJS 1 only
423
	// push.apply(_, arraylike) throws on ancient WebKit
424
	merge: function( first, second ) {
425
		var len = +second.length,
426
			j = 0,
427
			i = first.length;
428

429
		for ( ; j < len; j++ ) {
430
			first[ i++ ] = second[ j ];
431
		}
432

433
		first.length = i;
434

435
		return first;
436
	},
437

438
	grep: function( elems, callback, invert ) {
439
		var callbackInverse,
440
			matches = [],
441
			i = 0,
442
			length = elems.length,
443
			callbackExpect = !invert;
444

445
		// Go through the array, only saving the items
446
		// that pass the validator function
447
		for ( ; i < length; i++ ) {
448
			callbackInverse = !callback( elems[ i ], i );
449
			if ( callbackInverse !== callbackExpect ) {
450
				matches.push( elems[ i ] );
451
			}
452
		}
453

454
		return matches;
455
	},
456

457
	// arg is for internal usage only
458
	map: function( elems, callback, arg ) {
459
		var length, value,
460
			i = 0,
461
			ret = [];
462

463
		// Go through the array, translating each of the items to their new values
464
		if ( isArrayLike( elems ) ) {
465
			length = elems.length;
466
			for ( ; i < length; i++ ) {
467
				value = callback( elems[ i ], i, arg );
468

469
				if ( value != null ) {
470
					ret.push( value );
471
				}
472
			}
473

474
		// Go through every key on the object,
475
		} else {
476
			for ( i in elems ) {
477
				value = callback( elems[ i ], i, arg );
478

479
				if ( value != null ) {
480
					ret.push( value );
481
				}
482
			}
483
		}
484

485
		// Flatten any nested arrays
486
		return flat( ret );
487
	},
488

489
	// A global GUID counter for objects
490
	guid: 1,
491

492
	// jQuery.support is not used in Core but other projects attach their
493
	// properties to it so it needs to exist.
494
	support: support
495
} );
496

497
if ( typeof Symbol === "function" ) {
498
	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
499
}
500

501
// Populate the class2type map
502
jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
503
	function( _i, name ) {
504
		class2type[ "[object " + name + "]" ] = name.toLowerCase();
505
	} );
506

507
function isArrayLike( obj ) {
508

509
	// Support: real iOS 8.2 only (not reproducible in simulator)
510
	// `in` check used to prevent JIT error (gh-2145)
511
	// hasOwn isn't used here due to false negatives
512
	// regarding Nodelist length in IE
513
	var length = !!obj && "length" in obj && obj.length,
514
		type = toType( obj );
515

516
	if ( isFunction( obj ) || isWindow( obj ) ) {
517
		return false;
518
	}
519

520
	return type === "array" || length === 0 ||
521
		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
522
}
523
var Sizzle =
524
/*!
525
 * Sizzle CSS Selector Engine v2.3.6
526
 * https://sizzlejs.com/
527
 *
528
 * Copyright JS Foundation and other contributors
529
 * Released under the MIT license
530
 * https://js.foundation/
531
 *
532
 * Date: 2021-02-16
533
 */
534
( function( window ) {
535
var i,
536
	support,
537
	Expr,
538
	getText,
539
	isXML,
540
	tokenize,
541
	compile,
542
	select,
543
	outermostContext,
544
	sortInput,
545
	hasDuplicate,
546

547
	// Local document vars
548
	setDocument,
549
	document,
550
	docElem,
551
	documentIsHTML,
552
	rbuggyQSA,
553
	rbuggyMatches,
554
	matches,
555
	contains,
556

557
	// Instance-specific data
558
	expando = "sizzle" + 1 * new Date(),
559
	preferredDoc = window.document,
560
	dirruns = 0,
561
	done = 0,
562
	classCache = createCache(),
563
	tokenCache = createCache(),
564
	compilerCache = createCache(),
565
	nonnativeSelectorCache = createCache(),
566
	sortOrder = function( a, b ) {
567
		if ( a === b ) {
568
			hasDuplicate = true;
569
		}
570
		return 0;
571
	},
572

573
	// Instance methods
574
	hasOwn = ( {} ).hasOwnProperty,
575
	arr = [],
576
	pop = arr.pop,
577
	pushNative = arr.push,
578
	push = arr.push,
579
	slice = arr.slice,
580

581
	// Use a stripped-down indexOf as it's faster than native
582
	// https://jsperf.com/thor-indexof-vs-for/5
583
	indexOf = function( list, elem ) {
584
		var i = 0,
585
			len = list.length;
586
		for ( ; i < len; i++ ) {
587
			if ( list[ i ] === elem ) {
588
				return i;
589
			}
590
		}
591
		return -1;
592
	},
593

594
	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
595
		"ismap|loop|multiple|open|readonly|required|scoped",
596

597
	// Regular expressions
598

599
	// http://www.w3.org/TR/css3-selectors/#whitespace
600
	whitespace = "[\\x20\\t\\r\\n\\f]",
601

602
	// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
603
	identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
604
		"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
605

606
	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
607
	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
608

609
		// Operator (capture 2)
610
		"*([*^$|!~]?=)" + whitespace +
611

612
		// "Attribute values must be CSS identifiers [capture 5]
613
		// or strings [capture 3 or capture 4]"
614
		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
615
		whitespace + "*\\]",
616

617
	pseudos = ":(" + identifier + ")(?:\\((" +
618

619
		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
620
		// 1. quoted (capture 3; capture 4 or capture 5)
621
		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
622

623
		// 2. simple (capture 6)
624
		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
625

626
		// 3. anything else (capture 2)
627
		".*" +
628
		")\\)|)",
629

630
	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
631
	rwhitespace = new RegExp( whitespace + "+", "g" ),
632
	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
633
		whitespace + "+$", "g" ),
634

635
	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
636
	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
637
		"*" ),
638
	rdescend = new RegExp( whitespace + "|>" ),
639

640
	rpseudo = new RegExp( pseudos ),
641
	ridentifier = new RegExp( "^" + identifier + "$" ),
642

643
	matchExpr = {
644
		"ID": new RegExp( "^#(" + identifier + ")" ),
645
		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
646
		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
647
		"ATTR": new RegExp( "^" + attributes ),
648
		"PSEUDO": new RegExp( "^" + pseudos ),
649
		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
650
			whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
651
			whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
652
		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
653

654
		// For use in libraries implementing .is()
655
		// We use this for POS matching in `select`
656
		"needsContext": new RegExp( "^" + whitespace +
657
			"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
658
			"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
659
	},
660

661
	rhtml = /HTML$/i,
662
	rinputs = /^(?:input|select|textarea|button)$/i,
663
	rheader = /^h\d$/i,
664

665
	rnative = /^[^{]+\{\s*\[native \w/,
666

667
	// Easily-parseable/retrievable ID or TAG or CLASS selectors
668
	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
669

670
	rsibling = /[+~]/,
671

672
	// CSS escapes
673
	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
674
	runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
675
	funescape = function( escape, nonHex ) {
676
		var high = "0x" + escape.slice( 1 ) - 0x10000;
677

678
		return nonHex ?
679

680
			// Strip the backslash prefix from a non-hex escape sequence
681
			nonHex :
682

683
			// Replace a hexadecimal escape sequence with the encoded Unicode code point
684
			// Support: IE <=11+
685
			// For values outside the Basic Multilingual Plane (BMP), manually construct a
686
			// surrogate pair
687
			high < 0 ?
688
				String.fromCharCode( high + 0x10000 ) :
689
				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
690
	},
691

692
	// CSS string/identifier serialization
693
	// https://drafts.csswg.org/cssom/#common-serializing-idioms
694
	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
695
	fcssescape = function( ch, asCodePoint ) {
696
		if ( asCodePoint ) {
697

698
			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
699
			if ( ch === "\0" ) {
700
				return "\uFFFD";
701
			}
702

703
			// Control characters and (dependent upon position) numbers get escaped as code points
704
			return ch.slice( 0, -1 ) + "\\" +
705
				ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
706
		}
707

708
		// Other potentially-special ASCII characters get backslash-escaped
709
		return "\\" + ch;
710
	},
711

712
	// Used for iframes
713
	// See setDocument()
714
	// Removing the function wrapper causes a "Permission Denied"
715
	// error in IE
716
	unloadHandler = function() {
717
		setDocument();
718
	},
719

720
	inDisabledFieldset = addCombinator(
721
		function( elem ) {
722
			return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
723
		},
724
		{ dir: "parentNode", next: "legend" }
725
	);
726

727
// Optimize for push.apply( _, NodeList )
728
try {
729
	push.apply(
730
		( arr = slice.call( preferredDoc.childNodes ) ),
731
		preferredDoc.childNodes
732
	);
733

734
	// Support: Android<4.0
735
	// Detect silently failing push.apply
736
	// eslint-disable-next-line no-unused-expressions
737
	arr[ preferredDoc.childNodes.length ].nodeType;
738
} catch ( e ) {
739
	push = { apply: arr.length ?
740

741
		// Leverage slice if possible
742
		function( target, els ) {
743
			pushNative.apply( target, slice.call( els ) );
744
		} :
745

746
		// Support: IE<9
747
		// Otherwise append directly
748
		function( target, els ) {
749
			var j = target.length,
750
				i = 0;
751

752
			// Can't trust NodeList.length
753
			while ( ( target[ j++ ] = els[ i++ ] ) ) {}
754
			target.length = j - 1;
755
		}
756
	};
757
}
758

759
function Sizzle( selector, context, results, seed ) {
760
	var m, i, elem, nid, match, groups, newSelector,
761
		newContext = context && context.ownerDocument,
762

763
		// nodeType defaults to 9, since context defaults to document
764
		nodeType = context ? context.nodeType : 9;
765

766
	results = results || [];
767

768
	// Return early from calls with invalid selector or context
769
	if ( typeof selector !== "string" || !selector ||
770
		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
771

772
		return results;
773
	}
774

775
	// Try to shortcut find operations (as opposed to filters) in HTML documents
776
	if ( !seed ) {
777
		setDocument( context );
778
		context = context || document;
779

780
		if ( documentIsHTML ) {
781

782
			// If the selector is sufficiently simple, try using a "get*By*" DOM method
783
			// (excepting DocumentFragment context, where the methods don't exist)
784
			if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
785

786
				// ID selector
787
				if ( ( m = match[ 1 ] ) ) {
788

789
					// Document context
790
					if ( nodeType === 9 ) {
791
						if ( ( elem = context.getElementById( m ) ) ) {
792

793
							// Support: IE, Opera, Webkit
794
							// TODO: identify versions
795
							// getElementById can match elements by name instead of ID
796
							if ( elem.id === m ) {
797
								results.push( elem );
798
								return results;
799
							}
800
						} else {
801
							return results;
802
						}
803

804
					// Element context
805
					} else {
806

807
						// Support: IE, Opera, Webkit
808
						// TODO: identify versions
809
						// getElementById can match elements by name instead of ID
810
						if ( newContext && ( elem = newContext.getElementById( m ) ) &&
811
							contains( context, elem ) &&
812
							elem.id === m ) {
813

814
							results.push( elem );
815
							return results;
816
						}
817
					}
818

819
				// Type selector
820
				} else if ( match[ 2 ] ) {
821
					push.apply( results, context.getElementsByTagName( selector ) );
822
					return results;
823

824
				// Class selector
825
				} else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&
826
					context.getElementsByClassName ) {
827

828
					push.apply( results, context.getElementsByClassName( m ) );
829
					return results;
830
				}
831
			}
832

833
			// Take advantage of querySelectorAll
834
			if ( support.qsa &&
835
				!nonnativeSelectorCache[ selector + " " ] &&
836
				( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&
837

838
				// Support: IE 8 only
839
				// Exclude object elements
840
				( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) {
841

842
				newSelector = selector;
843
				newContext = context;
844

845
				// qSA considers elements outside a scoping root when evaluating child or
846
				// descendant combinators, which is not what we want.
847
				// In such cases, we work around the behavior by prefixing every selector in the
848
				// list with an ID selector referencing the scope context.
849
				// The technique has to be used as well when a leading combinator is used
850
				// as such selectors are not recognized by querySelectorAll.
851
				// Thanks to Andrew Dupont for this technique.
852
				if ( nodeType === 1 &&
853
					( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
854

855
					// Expand context for sibling selectors
856
					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
857
						context;
858

859
					// We can use :scope instead of the ID hack if the browser
860
					// supports it & if we're not changing the context.
861
					if ( newContext !== context || !support.scope ) {
862

863
						// Capture the context ID, setting it first if necessary
864
						if ( ( nid = context.getAttribute( "id" ) ) ) {
865
							nid = nid.replace( rcssescape, fcssescape );
866
						} else {
867
							context.setAttribute( "id", ( nid = expando ) );
868
						}
869
					}
870

871
					// Prefix every selector in the list
872
					groups = tokenize( selector );
873
					i = groups.length;
874
					while ( i-- ) {
875
						groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
876
							toSelector( groups[ i ] );
877
					}
878
					newSelector = groups.join( "," );
879
				}
880

881
				try {
882
					push.apply( results,
883
						newContext.querySelectorAll( newSelector )
884
					);
885
					return results;
886
				} catch ( qsaError ) {
887
					nonnativeSelectorCache( selector, true );
888
				} finally {
889
					if ( nid === expando ) {
890
						context.removeAttribute( "id" );
891
					}
892
				}
893
			}
894
		}
895
	}
896

897
	// All others
898
	return select( selector.replace( rtrim, "$1" ), context, results, seed );
899
}
900

901
/**
902
 * Create key-value caches of limited size
903
 * @returns {function(string, object)} Returns the Object data after storing it on itself with
904
 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
905
 *	deleting the oldest entry
906
 */
907
function createCache() {
908
	var keys = [];
909

910
	function cache( key, value ) {
911

912
		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
913
		if ( keys.push( key + " " ) > Expr.cacheLength ) {
914

915
			// Only keep the most recent entries
916
			delete cache[ keys.shift() ];
917
		}
918
		return ( cache[ key + " " ] = value );
919
	}
920
	return cache;
921
}
922

923
/**
924
 * Mark a function for special use by Sizzle
925
 * @param {Function} fn The function to mark
926
 */
927
function markFunction( fn ) {
928
	fn[ expando ] = true;
929
	return fn;
930
}
931

932
/**
933
 * Support testing using an element
934
 * @param {Function} fn Passed the created element and returns a boolean result
935
 */
936
function assert( fn ) {
937
	var el = document.createElement( "fieldset" );
938

939
	try {
940
		return !!fn( el );
941
	} catch ( e ) {
942
		return false;
943
	} finally {
944

945
		// Remove from its parent by default
946
		if ( el.parentNode ) {
947
			el.parentNode.removeChild( el );
948
		}
949

950
		// release memory in IE
951
		el = null;
952
	}
953
}
954

955
/**
956
 * Adds the same handler for all of the specified attrs
957
 * @param {String} attrs Pipe-separated list of attributes
958
 * @param {Function} handler The method that will be applied
959
 */
960
function addHandle( attrs, handler ) {
961
	var arr = attrs.split( "|" ),
962
		i = arr.length;
963

964
	while ( i-- ) {
965
		Expr.attrHandle[ arr[ i ] ] = handler;
966
	}
967
}
968

969
/**
970
 * Checks document order of two siblings
971
 * @param {Element} a
972
 * @param {Element} b
973
 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
974
 */
975
function siblingCheck( a, b ) {
976
	var cur = b && a,
977
		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
978
			a.sourceIndex - b.sourceIndex;
979

980
	// Use IE sourceIndex if available on both nodes
981
	if ( diff ) {
982
		return diff;
983
	}
984

985
	// Check if b follows a
986
	if ( cur ) {
987
		while ( ( cur = cur.nextSibling ) ) {
988
			if ( cur === b ) {
989
				return -1;
990
			}
991
		}
992
	}
993

994
	return a ? 1 : -1;
995
}
996

997
/**
998
 * Returns a function to use in pseudos for input types
999
 * @param {String} type
1000
 */
1001
function createInputPseudo( type ) {
1002
	return function( elem ) {
1003
		var name = elem.nodeName.toLowerCase();
1004
		return name === "input" && elem.type === type;
1005
	};
1006
}
1007

1008
/**
1009
 * Returns a function to use in pseudos for buttons
1010
 * @param {String} type
1011
 */
1012
function createButtonPseudo( type ) {
1013
	return function( elem ) {
1014
		var name = elem.nodeName.toLowerCase();
1015
		return ( name === "input" || name === "button" ) && elem.type === type;
1016
	};
1017
}
1018

1019
/**
1020
 * Returns a function to use in pseudos for :enabled/:disabled
1021
 * @param {Boolean} disabled true for :disabled; false for :enabled
1022
 */
1023
function createDisabledPseudo( disabled ) {
1024

1025
	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1026
	return function( elem ) {
1027

1028
		// Only certain elements can match :enabled or :disabled
1029
		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1030
		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1031
		if ( "form" in elem ) {
1032

1033
			// Check for inherited disabledness on relevant non-disabled elements:
1034
			// * listed form-associated elements in a disabled fieldset
1035
			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
1036
			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1037
			// * option elements in a disabled optgroup
1038
			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1039
			// All such elements have a "form" property.
1040
			if ( elem.parentNode && elem.disabled === false ) {
1041

1042
				// Option elements defer to a parent optgroup if present
1043
				if ( "label" in elem ) {
1044
					if ( "label" in elem.parentNode ) {
1045
						return elem.parentNode.disabled === disabled;
1046
					} else {
1047
						return elem.disabled === disabled;
1048
					}
1049
				}
1050

1051
				// Support: IE 6 - 11
1052
				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
1053
				return elem.isDisabled === disabled ||
1054

1055
					// Where there is no isDisabled, check manually
1056
					/* jshint -W018 */
1057
					elem.isDisabled !== !disabled &&
1058
					inDisabledFieldset( elem ) === disabled;
1059
			}
1060

1061
			return elem.disabled === disabled;
1062

1063
		// Try to winnow out elements that can't be disabled before trusting the disabled property.
1064
		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1065
		// even exist on them, let alone have a boolean value.
1066
		} else if ( "label" in elem ) {
1067
			return elem.disabled === disabled;
1068
		}
1069

1070
		// Remaining elements are neither :enabled nor :disabled
1071
		return false;
1072
	};
1073
}
1074

1075
/**
1076
 * Returns a function to use in pseudos for positionals
1077
 * @param {Function} fn
1078
 */
1079
function createPositionalPseudo( fn ) {
1080
	return markFunction( function( argument ) {
1081
		argument = +argument;
1082
		return markFunction( function( seed, matches ) {
1083
			var j,
1084
				matchIndexes = fn( [], seed.length, argument ),
1085
				i = matchIndexes.length;
1086

1087
			// Match elements found at the specified indexes
1088
			while ( i-- ) {
1089
				if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
1090
					seed[ j ] = !( matches[ j ] = seed[ j ] );
1091
				}
1092
			}
1093
		} );
1094
	} );
1095
}
1096

1097
/**
1098
 * Checks a node for validity as a Sizzle context
1099
 * @param {Element|Object=} context
1100
 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1101
 */
1102
function testContext( context ) {
1103
	return context && typeof context.getElementsByTagName !== "undefined" && context;
1104
}
1105

1106
// Expose support vars for convenience
1107
support = Sizzle.support = {};
1108

1109
/**
1110
 * Detects XML nodes
1111
 * @param {Element|Object} elem An element or a document
1112
 * @returns {Boolean} True iff elem is a non-HTML XML node
1113
 */
1114
isXML = Sizzle.isXML = function( elem ) {
1115
	var namespace = elem && elem.namespaceURI,
1116
		docElem = elem && ( elem.ownerDocument || elem ).documentElement;
1117

1118
	// Support: IE <=8
1119
	// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
1120
	// https://bugs.jquery.com/ticket/4833
1121
	return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
1122
};
1123

1124
/**
1125
 * Sets document-related variables once based on the current document
1126
 * @param {Element|Object} [doc] An element or document object to use to set the document
1127
 * @returns {Object} Returns the current document
1128
 */
1129
setDocument = Sizzle.setDocument = function( node ) {
1130
	var hasCompare, subWindow,
1131
		doc = node ? node.ownerDocument || node : preferredDoc;
1132

1133
	// Return early if doc is invalid or already selected
1134
	// Support: IE 11+, Edge 17 - 18+
1135
	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1136
	// two documents; shallow comparisons work.
1137
	// eslint-disable-next-line eqeqeq
1138
	if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
1139
		return document;
1140
	}
1141

1142
	// Update global variables
1143
	document = doc;
1144
	docElem = document.documentElement;
1145
	documentIsHTML = !isXML( document );
1146

1147
	// Support: IE 9 - 11+, Edge 12 - 18+
1148
	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1149
	// Support: IE 11+, Edge 17 - 18+
1150
	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1151
	// two documents; shallow comparisons work.
1152
	// eslint-disable-next-line eqeqeq
1153
	if ( preferredDoc != document &&
1154
		( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
1155

1156
		// Support: IE 11, Edge
1157
		if ( subWindow.addEventListener ) {
1158
			subWindow.addEventListener( "unload", unloadHandler, false );
1159

1160
		// Support: IE 9 - 10 only
1161
		} else if ( subWindow.attachEvent ) {
1162
			subWindow.attachEvent( "onunload", unloadHandler );
1163
		}
1164
	}
1165

1166
	// Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,
1167
	// Safari 4 - 5 only, Opera <=11.6 - 12.x only
1168
	// IE/Edge & older browsers don't support the :scope pseudo-class.
1169
	// Support: Safari 6.0 only
1170
	// Safari 6.0 supports :scope but it's an alias of :root there.
1171
	support.scope = assert( function( el ) {
1172
		docElem.appendChild( el ).appendChild( document.createElement( "div" ) );
1173
		return typeof el.querySelectorAll !== "undefined" &&
1174
			!el.querySelectorAll( ":scope fieldset div" ).length;
1175
	} );
1176

1177
	/* Attributes
1178
	---------------------------------------------------------------------- */
1179

1180
	// Support: IE<8
1181
	// Verify that getAttribute really returns attributes and not properties
1182
	// (excepting IE8 booleans)
1183
	support.attributes = assert( function( el ) {
1184
		el.className = "i";
1185
		return !el.getAttribute( "className" );
1186
	} );
1187

1188
	/* getElement(s)By*
1189
	---------------------------------------------------------------------- */
1190

1191
	// Check if getElementsByTagName("*") returns only elements
1192
	support.getElementsByTagName = assert( function( el ) {
1193
		el.appendChild( document.createComment( "" ) );
1194
		return !el.getElementsByTagName( "*" ).length;
1195
	} );
1196

1197
	// Support: IE<9
1198
	support.getElementsByClassName = rnative.test( document.getElementsByClassName );
1199

1200
	// Support: IE<10
1201
	// Check if getElementById returns elements by name
1202
	// The broken getElementById methods don't pick up programmatically-set names,
1203
	// so use a roundabout getElementsByName test
1204
	support.getById = assert( function( el ) {
1205
		docElem.appendChild( el ).id = expando;
1206
		return !document.getElementsByName || !document.getElementsByName( expando ).length;
1207
	} );
1208

1209
	// ID filter and find
1210
	if ( support.getById ) {
1211
		Expr.filter[ "ID" ] = function( id ) {
1212
			var attrId = id.replace( runescape, funescape );
1213
			return function( elem ) {
1214
				return elem.getAttribute( "id" ) === attrId;
1215
			};
1216
		};
1217
		Expr.find[ "ID" ] = function( id, context ) {
1218
			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1219
				var elem = context.getElementById( id );
1220
				return elem ? [ elem ] : [];
1221
			}
1222
		};
1223
	} else {
1224
		Expr.filter[ "ID" ] =  function( id ) {
1225
			var attrId = id.replace( runescape, funescape );
1226
			return function( elem ) {
1227
				var node = typeof elem.getAttributeNode !== "undefined" &&
1228
					elem.getAttributeNode( "id" );
1229
				return node && node.value === attrId;
1230
			};
1231
		};
1232

1233
		// Support: IE 6 - 7 only
1234
		// getElementById is not reliable as a find shortcut
1235
		Expr.find[ "ID" ] = function( id, context ) {
1236
			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1237
				var node, i, elems,
1238
					elem = context.getElementById( id );
1239

1240
				if ( elem ) {
1241

1242
					// Verify the id attribute
1243
					node = elem.getAttributeNode( "id" );
1244
					if ( node && node.value === id ) {
1245
						return [ elem ];
1246
					}
1247

1248
					// Fall back on getElementsByName
1249
					elems = context.getElementsByName( id );
1250
					i = 0;
1251
					while ( ( elem = elems[ i++ ] ) ) {
1252
						node = elem.getAttributeNode( "id" );
1253
						if ( node && node.value === id ) {
1254
							return [ elem ];
1255
						}
1256
					}
1257
				}
1258

1259
				return [];
1260
			}
1261
		};
1262
	}
1263

1264
	// Tag
1265
	Expr.find[ "TAG" ] = support.getElementsByTagName ?
1266
		function( tag, context ) {
1267
			if ( typeof context.getElementsByTagName !== "undefined" ) {
1268
				return context.getElementsByTagName( tag );
1269

1270
			// DocumentFragment nodes don't have gEBTN
1271
			} else if ( support.qsa ) {
1272
				return context.querySelectorAll( tag );
1273
			}
1274
		} :
1275

1276
		function( tag, context ) {
1277
			var elem,
1278
				tmp = [],
1279
				i = 0,
1280

1281
				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1282
				results = context.getElementsByTagName( tag );
1283

1284
			// Filter out possible comments
1285
			if ( tag === "*" ) {
1286
				while ( ( elem = results[ i++ ] ) ) {
1287
					if ( elem.nodeType === 1 ) {
1288
						tmp.push( elem );
1289
					}
1290
				}
1291

1292
				return tmp;
1293
			}
1294
			return results;
1295
		};
1296

1297
	// Class
1298
	Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) {
1299
		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1300
			return context.getElementsByClassName( className );
1301
		}
1302
	};
1303

1304
	/* QSA/matchesSelector
1305
	---------------------------------------------------------------------- */
1306

1307
	// QSA and matchesSelector support
1308

1309
	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1310
	rbuggyMatches = [];
1311

1312
	// qSa(:focus) reports false when true (Chrome 21)
1313
	// We allow this because of a bug in IE8/9 that throws an error
1314
	// whenever `document.activeElement` is accessed on an iframe
1315
	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1316
	// See https://bugs.jquery.com/ticket/13378
1317
	rbuggyQSA = [];
1318

1319
	if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {
1320

1321
		// Build QSA regex
1322
		// Regex strategy adopted from Diego Perini
1323
		assert( function( el ) {
1324

1325
			var input;
1326

1327
			// Select is set to empty string on purpose
1328
			// This is to test IE's treatment of not explicitly
1329
			// setting a boolean content attribute,
1330
			// since its presence should be enough
1331
			// https://bugs.jquery.com/ticket/12359
1332
			docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
1333
				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
1334
				"<option selected=''></option></select>";
1335

1336
			// Support: IE8, Opera 11-12.16
1337
			// Nothing should be selected when empty strings follow ^= or $= or *=
1338
			// The test attribute must be unknown in Opera but "safe" for WinRT
1339
			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1340
			if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) {
1341
				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1342
			}
1343

1344
			// Support: IE8
1345
			// Boolean attributes and "value" are not treated correctly
1346
			if ( !el.querySelectorAll( "[selected]" ).length ) {
1347
				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1348
			}
1349

1350
			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1351
			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1352
				rbuggyQSA.push( "~=" );
1353
			}
1354

1355
			// Support: IE 11+, Edge 15 - 18+
1356
			// IE 11/Edge don't find elements on a `[name='']` query in some cases.
1357
			// Adding a temporary attribute to the document before the selection works
1358
			// around the issue.
1359
			// Interestingly, IE 10 & older don't seem to have the issue.
1360
			input = document.createElement( "input" );
1361
			input.setAttribute( "name", "" );
1362
			el.appendChild( input );
1363
			if ( !el.querySelectorAll( "[name='']" ).length ) {
1364
				rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
1365
					whitespace + "*(?:''|\"\")" );
1366
			}
1367

1368
			// Webkit/Opera - :checked should return selected option elements
1369
			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1370
			// IE8 throws error here and will not see later tests
1371
			if ( !el.querySelectorAll( ":checked" ).length ) {
1372
				rbuggyQSA.push( ":checked" );
1373
			}
1374

1375
			// Support: Safari 8+, iOS 8+
1376
			// https://bugs.webkit.org/show_bug.cgi?id=136851
1377
			// In-page `selector#id sibling-combinator selector` fails
1378
			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
1379
				rbuggyQSA.push( ".#.+[+~]" );
1380
			}
1381

1382
			// Support: Firefox <=3.6 - 5 only
1383
			// Old Firefox doesn't throw on a badly-escaped identifier.
1384
			el.querySelectorAll( "\\\f" );
1385
			rbuggyQSA.push( "[\\r\\n\\f]" );
1386
		} );
1387

1388
		assert( function( el ) {
1389
			el.innerHTML = "<a href='' disabled='disabled'></a>" +
1390
				"<select disabled='disabled'><option/></select>";
1391

1392
			// Support: Windows 8 Native Apps
1393
			// The type and name attributes are restricted during .innerHTML assignment
1394
			var input = document.createElement( "input" );
1395
			input.setAttribute( "type", "hidden" );
1396
			el.appendChild( input ).setAttribute( "name", "D" );
1397

1398
			// Support: IE8
1399
			// Enforce case-sensitivity of name attribute
1400
			if ( el.querySelectorAll( "[name=d]" ).length ) {
1401
				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1402
			}
1403

1404
			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1405
			// IE8 throws error here and will not see later tests
1406
			if ( el.querySelectorAll( ":enabled" ).length !== 2 ) {
1407
				rbuggyQSA.push( ":enabled", ":disabled" );
1408
			}
1409

1410
			// Support: IE9-11+
1411
			// IE's :disabled selector does not pick up the children of disabled fieldsets
1412
			docElem.appendChild( el ).disabled = true;
1413
			if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
1414
				rbuggyQSA.push( ":enabled", ":disabled" );
1415
			}
1416

1417
			// Support: Opera 10 - 11 only
1418
			// Opera 10-11 does not throw on post-comma invalid pseudos
1419
			el.querySelectorAll( "*,:x" );
1420
			rbuggyQSA.push( ",.*:" );
1421
		} );
1422
	}
1423

1424
	if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||
1425
		docElem.webkitMatchesSelector ||
1426
		docElem.mozMatchesSelector ||
1427
		docElem.oMatchesSelector ||
1428
		docElem.msMatchesSelector ) ) ) ) {
1429

1430
		assert( function( el ) {
1431

1432
			// Check to see if it's possible to do matchesSelector
1433
			// on a disconnected node (IE 9)
1434
			support.disconnectedMatch = matches.call( el, "*" );
1435

1436
			// This should fail with an exception
1437
			// Gecko does not error, returns false instead
1438
			matches.call( el, "[s!='']:x" );
1439
			rbuggyMatches.push( "!=", pseudos );
1440
		} );
1441
	}
1442

1443
	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
1444
	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) );
1445

1446
	/* Contains
1447
	---------------------------------------------------------------------- */
1448
	hasCompare = rnative.test( docElem.compareDocumentPosition );
1449

1450
	// Element contains another
1451
	// Purposefully self-exclusive
1452
	// As in, an element does not contain itself
1453
	contains = hasCompare || rnative.test( docElem.contains ) ?
1454
		function( a, b ) {
1455
			var adown = a.nodeType === 9 ? a.documentElement : a,
1456
				bup = b && b.parentNode;
1457
			return a === bup || !!( bup && bup.nodeType === 1 && (
1458
				adown.contains ?
1459
					adown.contains( bup ) :
1460
					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1461
			) );
1462
		} :
1463
		function( a, b ) {
1464
			if ( b ) {
1465
				while ( ( b = b.parentNode ) ) {
1466
					if ( b === a ) {
1467
						return true;
1468
					}
1469
				}
1470
			}
1471
			return false;
1472
		};
1473

1474
	/* Sorting
1475
	---------------------------------------------------------------------- */
1476

1477
	// Document order sorting
1478
	sortOrder = hasCompare ?
1479
	function( a, b ) {
1480

1481
		// Flag for duplicate removal
1482
		if ( a === b ) {
1483
			hasDuplicate = true;
1484
			return 0;
1485
		}
1486

1487
		// Sort on method existence if only one input has compareDocumentPosition
1488
		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1489
		if ( compare ) {
1490
			return compare;
1491
		}
1492

1493
		// Calculate position if both inputs belong to the same document
1494
		// Support: IE 11+, Edge 17 - 18+
1495
		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1496
		// two documents; shallow comparisons work.
1497
		// eslint-disable-next-line eqeqeq
1498
		compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
1499
			a.compareDocumentPosition( b ) :
1500

1501
			// Otherwise we know they are disconnected
1502
			1;
1503

1504
		// Disconnected nodes
1505
		if ( compare & 1 ||
1506
			( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {
1507

1508
			// Choose the first element that is related to our preferred document
1509
			// Support: IE 11+, Edge 17 - 18+
1510
			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1511
			// two documents; shallow comparisons work.
1512
			// eslint-disable-next-line eqeqeq
1513
			if ( a == document || a.ownerDocument == preferredDoc &&
1514
				contains( preferredDoc, a ) ) {
1515
				return -1;
1516
			}
1517

1518
			// Support: IE 11+, Edge 17 - 18+
1519
			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1520
			// two documents; shallow comparisons work.
1521
			// eslint-disable-next-line eqeqeq
1522
			if ( b == document || b.ownerDocument == preferredDoc &&
1523
				contains( preferredDoc, b ) ) {
1524
				return 1;
1525
			}
1526

1527
			// Maintain original order
1528
			return sortInput ?
1529
				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1530
				0;
1531
		}
1532

1533
		return compare & 4 ? -1 : 1;
1534
	} :
1535
	function( a, b ) {
1536

1537
		// Exit early if the nodes are identical
1538
		if ( a === b ) {
1539
			hasDuplicate = true;
1540
			return 0;
1541
		}
1542

1543
		var cur,
1544
			i = 0,
1545
			aup = a.parentNode,
1546
			bup = b.parentNode,
1547
			ap = [ a ],
1548
			bp = [ b ];
1549

1550
		// Parentless nodes are either documents or disconnected
1551
		if ( !aup || !bup ) {
1552

1553
			// Support: IE 11+, Edge 17 - 18+
1554
			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1555
			// two documents; shallow comparisons work.
1556
			/* eslint-disable eqeqeq */
1557
			return a == document ? -1 :
1558
				b == document ? 1 :
1559
				/* eslint-enable eqeqeq */
1560
				aup ? -1 :
1561
				bup ? 1 :
1562
				sortInput ?
1563
				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1564
				0;
1565

1566
		// If the nodes are siblings, we can do a quick check
1567
		} else if ( aup === bup ) {
1568
			return siblingCheck( a, b );
1569
		}
1570

1571
		// Otherwise we need full lists of their ancestors for comparison
1572
		cur = a;
1573
		while ( ( cur = cur.parentNode ) ) {
1574
			ap.unshift( cur );
1575
		}
1576
		cur = b;
1577
		while ( ( cur = cur.parentNode ) ) {
1578
			bp.unshift( cur );
1579
		}
1580

1581
		// Walk down the tree looking for a discrepancy
1582
		while ( ap[ i ] === bp[ i ] ) {
1583
			i++;
1584
		}
1585

1586
		return i ?
1587

1588
			// Do a sibling check if the nodes have a common ancestor
1589
			siblingCheck( ap[ i ], bp[ i ] ) :
1590

1591
			// Otherwise nodes in our document sort first
1592
			// Support: IE 11+, Edge 17 - 18+
1593
			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1594
			// two documents; shallow comparisons work.
1595
			/* eslint-disable eqeqeq */
1596
			ap[ i ] == preferredDoc ? -1 :
1597
			bp[ i ] == preferredDoc ? 1 :
1598
			/* eslint-enable eqeqeq */
1599
			0;
1600
	};
1601

1602
	return document;
1603
};
1604

1605
Sizzle.matches = function( expr, elements ) {
1606
	return Sizzle( expr, null, null, elements );
1607
};
1608

1609
Sizzle.matchesSelector = function( elem, expr ) {
1610
	setDocument( elem );
1611

1612
	if ( support.matchesSelector && documentIsHTML &&
1613
		!nonnativeSelectorCache[ expr + " " ] &&
1614
		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1615
		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1616

1617
		try {
1618
			var ret = matches.call( elem, expr );
1619

1620
			// IE 9's matchesSelector returns false on disconnected nodes
1621
			if ( ret || support.disconnectedMatch ||
1622

1623
				// As well, disconnected nodes are said to be in a document
1624
				// fragment in IE 9
1625
				elem.document && elem.document.nodeType !== 11 ) {
1626
				return ret;
1627
			}
1628
		} catch ( e ) {
1629
			nonnativeSelectorCache( expr, true );
1630
		}
1631
	}
1632

1633
	return Sizzle( expr, document, null, [ elem ] ).length > 0;
1634
};
1635

1636
Sizzle.contains = function( context, elem ) {
1637

1638
	// Set document vars if needed
1639
	// Support: IE 11+, Edge 17 - 18+
1640
	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1641
	// two documents; shallow comparisons work.
1642
	// eslint-disable-next-line eqeqeq
1643
	if ( ( context.ownerDocument || context ) != document ) {
1644
		setDocument( context );
1645
	}
1646
	return contains( context, elem );
1647
};
1648

1649
Sizzle.attr = function( elem, name ) {
1650

1651
	// Set document vars if needed
1652
	// Support: IE 11+, Edge 17 - 18+
1653
	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1654
	// two documents; shallow comparisons work.
1655
	// eslint-disable-next-line eqeqeq
1656
	if ( ( elem.ownerDocument || elem ) != document ) {
1657
		setDocument( elem );
1658
	}
1659

1660
	var fn = Expr.attrHandle[ name.toLowerCase() ],
1661

1662
		// Don't get fooled by Object.prototype properties (jQuery #13807)
1663
		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1664
			fn( elem, name, !documentIsHTML ) :
1665
			undefined;
1666

1667
	return val !== undefined ?
1668
		val :
1669
		support.attributes || !documentIsHTML ?
1670
			elem.getAttribute( name ) :
1671
			( val = elem.getAttributeNode( name ) ) && val.specified ?
1672
				val.value :
1673
				null;
1674
};
1675

1676
Sizzle.escape = function( sel ) {
1677
	return ( sel + "" ).replace( rcssescape, fcssescape );
1678
};
1679

1680
Sizzle.error = function( msg ) {
1681
	throw new Error( "Syntax error, unrecognized expression: " + msg );
1682
};
1683

1684
/**
1685
 * Document sorting and removing duplicates
1686
 * @param {ArrayLike} results
1687
 */
1688
Sizzle.uniqueSort = function( results ) {
1689
	var elem,
1690
		duplicates = [],
1691
		j = 0,
1692
		i = 0;
1693

1694
	// Unless we *know* we can detect duplicates, assume their presence
1695
	hasDuplicate = !support.detectDuplicates;
1696
	sortInput = !support.sortStable && results.slice( 0 );
1697
	results.sort( sortOrder );
1698

1699
	if ( hasDuplicate ) {
1700
		while ( ( elem = results[ i++ ] ) ) {
1701
			if ( elem === results[ i ] ) {
1702
				j = duplicates.push( i );
1703
			}
1704
		}
1705
		while ( j-- ) {
1706
			results.splice( duplicates[ j ], 1 );
1707
		}
1708
	}
1709

1710
	// Clear input after sorting to release objects
1711
	// See https://github.com/jquery/sizzle/pull/225
1712
	sortInput = null;
1713

1714
	return results;
1715
};
1716

1717
/**
1718
 * Utility function for retrieving the text value of an array of DOM nodes
1719
 * @param {Array|Element} elem
1720
 */
1721
getText = Sizzle.getText = function( elem ) {
1722
	var node,
1723
		ret = "",
1724
		i = 0,
1725
		nodeType = elem.nodeType;
1726

1727
	if ( !nodeType ) {
1728

1729
		// If no nodeType, this is expected to be an array
1730
		while ( ( node = elem[ i++ ] ) ) {
1731

1732
			// Do not traverse comment nodes
1733
			ret += getText( node );
1734
		}
1735
	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1736

1737
		// Use textContent for elements
1738
		// innerText usage removed for consistency of new lines (jQuery #11153)
1739
		if ( typeof elem.textContent === "string" ) {
1740
			return elem.textContent;
1741
		} else {
1742

1743
			// Traverse its children
1744
			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1745
				ret += getText( elem );
1746
			}
1747
		}
1748
	} else if ( nodeType === 3 || nodeType === 4 ) {
1749
		return elem.nodeValue;
1750
	}
1751

1752
	// Do not include comment or processing instruction nodes
1753

1754
	return ret;
1755
};
1756

1757
Expr = Sizzle.selectors = {
1758

1759
	// Can be adjusted by the user
1760
	cacheLength: 50,
1761

1762
	createPseudo: markFunction,
1763

1764
	match: matchExpr,
1765

1766
	attrHandle: {},
1767

1768
	find: {},
1769

1770
	relative: {
1771
		">": { dir: "parentNode", first: true },
1772
		" ": { dir: "parentNode" },
1773
		"+": { dir: "previousSibling", first: true },
1774
		"~": { dir: "previousSibling" }
1775
	},
1776

1777
	preFilter: {
1778
		"ATTR": function( match ) {
1779
			match[ 1 ] = match[ 1 ].replace( runescape, funescape );
1780

1781
			// Move the given value to match[3] whether quoted or unquoted
1782
			match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||
1783
				match[ 5 ] || "" ).replace( runescape, funescape );
1784

1785
			if ( match[ 2 ] === "~=" ) {
1786
				match[ 3 ] = " " + match[ 3 ] + " ";
1787
			}
1788

1789
			return match.slice( 0, 4 );
1790
		},
1791

1792
		"CHILD": function( match ) {
1793

1794
			/* matches from matchExpr["CHILD"]
1795
				1 type (only|nth|...)
1796
				2 what (child|of-type)
1797
				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1798
				4 xn-component of xn+y argument ([+-]?\d*n|)
1799
				5 sign of xn-component
1800
				6 x of xn-component
1801
				7 sign of y-component
1802
				8 y of y-component
1803
			*/
1804
			match[ 1 ] = match[ 1 ].toLowerCase();
1805

1806
			if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
1807

1808
				// nth-* requires argument
1809
				if ( !match[ 3 ] ) {
1810
					Sizzle.error( match[ 0 ] );
1811
				}
1812

1813
				// numeric x and y parameters for Expr.filter.CHILD
1814
				// remember that false/true cast respectively to 0/1
1815
				match[ 4 ] = +( match[ 4 ] ?
1816
					match[ 5 ] + ( match[ 6 ] || 1 ) :
1817
					2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) );
1818
				match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
1819

1820
				// other types prohibit arguments
1821
			} else if ( match[ 3 ] ) {
1822
				Sizzle.error( match[ 0 ] );
1823
			}
1824

1825
			return match;
1826
		},
1827

1828
		"PSEUDO": function( match ) {
1829
			var excess,
1830
				unquoted = !match[ 6 ] && match[ 2 ];
1831

1832
			if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) {
1833
				return null;
1834
			}
1835

1836
			// Accept quoted arguments as-is
1837
			if ( match[ 3 ] ) {
1838
				match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
1839

1840
			// Strip excess characters from unquoted arguments
1841
			} else if ( unquoted && rpseudo.test( unquoted ) &&
1842

1843
				// Get excess from tokenize (recursively)
1844
				( excess = tokenize( unquoted, true ) ) &&
1845

1846
				// advance to the next closing parenthesis
1847
				( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
1848

1849
				// excess is a negative index
1850
				match[ 0 ] = match[ 0 ].slice( 0, excess );
1851
				match[ 2 ] = unquoted.slice( 0, excess );
1852
			}
1853

1854
			// Return only captures needed by the pseudo filter method (type and argument)
1855
			return match.slice( 0, 3 );
1856
		}
1857
	},
1858

1859
	filter: {
1860

1861
		"TAG": function( nodeNameSelector ) {
1862
			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1863
			return nodeNameSelector === "*" ?
1864
				function() {
1865
					return true;
1866
				} :
1867
				function( elem ) {
1868
					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1869
				};
1870
		},
1871

1872
		"CLASS": function( className ) {
1873
			var pattern = classCache[ className + " " ];
1874

1875
			return pattern ||
1876
				( pattern = new RegExp( "(^|" + whitespace +
1877
					")" + className + "(" + whitespace + "|$)" ) ) && classCache(
1878
						className, function( elem ) {
1879
							return pattern.test(
1880
								typeof elem.className === "string" && elem.className ||
1881
								typeof elem.getAttribute !== "undefined" &&
1882
									elem.getAttribute( "class" ) ||
1883
								""
1884
							);
1885
				} );
1886
		},
1887

1888
		"ATTR": function( name, operator, check ) {
1889
			return function( elem ) {
1890
				var result = Sizzle.attr( elem, name );
1891

1892
				if ( result == null ) {
1893
					return operator === "!=";
1894
				}
1895
				if ( !operator ) {
1896
					return true;
1897
				}
1898

1899
				result += "";
1900

1901
				/* eslint-disable max-len */
1902

1903
				return operator === "=" ? result === check :
1904
					operator === "!=" ? result !== check :
1905
					operator === "^=" ? check && result.indexOf( check ) === 0 :
1906
					operator === "*=" ? check && result.indexOf( check ) > -1 :
1907
					operator === "$=" ? check && result.slice( -check.length ) === check :
1908
					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1909
					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1910
					false;
1911
				/* eslint-enable max-len */
1912

1913
			};
1914
		},
1915

1916
		"CHILD": function( type, what, _argument, first, last ) {
1917
			var simple = type.slice( 0, 3 ) !== "nth",
1918
				forward = type.slice( -4 ) !== "last",
1919
				ofType = what === "of-type";
1920

1921
			return first === 1 && last === 0 ?
1922

1923
				// Shortcut for :nth-*(n)
1924
				function( elem ) {
1925
					return !!elem.parentNode;
1926
				} :
1927

1928
				function( elem, _context, xml ) {
1929
					var cache, uniqueCache, outerCache, node, nodeIndex, start,
1930
						dir = simple !== forward ? "nextSibling" : "previousSibling",
1931
						parent = elem.parentNode,
1932
						name = ofType && elem.nodeName.toLowerCase(),
1933
						useCache = !xml && !ofType,
1934
						diff = false;
1935

1936
					if ( parent ) {
1937

1938
						// :(first|last|only)-(child|of-type)
1939
						if ( simple ) {
1940
							while ( dir ) {
1941
								node = elem;
1942
								while ( ( node = node[ dir ] ) ) {
1943
									if ( ofType ?
1944
										node.nodeName.toLowerCase() === name :
1945
										node.nodeType === 1 ) {
1946

1947
										return false;
1948
									}
1949
								}
1950

1951
								// Reverse direction for :only-* (if we haven't yet done so)
1952
								start = dir = type === "only" && !start && "nextSibling";
1953
							}
1954
							return true;
1955
						}
1956

1957
						start = [ forward ? parent.firstChild : parent.lastChild ];
1958

1959
						// non-xml :nth-child(...) stores cache data on `parent`
1960
						if ( forward && useCache ) {
1961

1962
							// Seek `elem` from a previously-cached index
1963

1964
							// ...in a gzip-friendly way
1965
							node = parent;
1966
							outerCache = node[ expando ] || ( node[ expando ] = {} );
1967

1968
							// Support: IE <9 only
1969
							// Defend against cloned attroperties (jQuery gh-1709)
1970
							uniqueCache = outerCache[ node.uniqueID ] ||
1971
								( outerCache[ node.uniqueID ] = {} );
1972

1973
							cache = uniqueCache[ type ] || [];
1974
							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1975
							diff = nodeIndex && cache[ 2 ];
1976
							node = nodeIndex && parent.childNodes[ nodeIndex ];
1977

1978
							while ( ( node = ++nodeIndex && node && node[ dir ] ||
1979

1980
								// Fallback to seeking `elem` from the start
1981
								( diff = nodeIndex = 0 ) || start.pop() ) ) {
1982

1983
								// When found, cache indexes on `parent` and break
1984
								if ( node.nodeType === 1 && ++diff && node === elem ) {
1985
									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1986
									break;
1987
								}
1988
							}
1989

1990
						} else {
1991

1992
							// Use previously-cached element index if available
1993
							if ( useCache ) {
1994

1995
								// ...in a gzip-friendly way
1996
								node = elem;
1997
								outerCache = node[ expando ] || ( node[ expando ] = {} );
1998

1999
								// Support: IE <9 only
2000
								// Defend against cloned attroperties (jQuery gh-1709)
2001
								uniqueCache = outerCache[ node.uniqueID ] ||
2002
									( outerCache[ node.uniqueID ] = {} );
2003

2004
								cache = uniqueCache[ type ] || [];
2005
								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
2006
								diff = nodeIndex;
2007
							}
2008

2009
							// xml :nth-child(...)
2010
							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
2011
							if ( diff === false ) {
2012

2013
								// Use the same loop as above to seek `elem` from the start
2014
								while ( ( node = ++nodeIndex && node && node[ dir ] ||
2015
									( diff = nodeIndex = 0 ) || start.pop() ) ) {
2016

2017
									if ( ( ofType ?
2018
										node.nodeName.toLowerCase() === name :
2019
										node.nodeType === 1 ) &&
2020
										++diff ) {
2021

2022
										// Cache the index of each encountered element
2023
										if ( useCache ) {
2024
											outerCache = node[ expando ] ||
2025
												( node[ expando ] = {} );
2026

2027
											// Support: IE <9 only
2028
											// Defend against cloned attroperties (jQuery gh-1709)
2029
											uniqueCache = outerCache[ node.uniqueID ] ||
2030
												( outerCache[ node.uniqueID ] = {} );
2031

2032
											uniqueCache[ type ] = [ dirruns, diff ];
2033
										}
2034

2035
										if ( node === elem ) {
2036
											break;
2037
										}
2038
									}
2039
								}
2040
							}
2041
						}
2042

2043
						// Incorporate the offset, then check against cycle size
2044
						diff -= last;
2045
						return diff === first || ( diff % first === 0 && diff / first >= 0 );
2046
					}
2047
				};
2048
		},
2049

2050
		"PSEUDO": function( pseudo, argument ) {
2051

2052
			// pseudo-class names are case-insensitive
2053
			// http://www.w3.org/TR/selectors/#pseudo-classes
2054
			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2055
			// Remember that setFilters inherits from pseudos
2056
			var args,
2057
				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2058
					Sizzle.error( "unsupported pseudo: " + pseudo );
2059

2060
			// The user may use createPseudo to indicate that
2061
			// arguments are needed to create the filter function
2062
			// just as Sizzle does
2063
			if ( fn[ expando ] ) {
2064
				return fn( argument );
2065
			}
2066

2067
			// But maintain support for old signatures
2068
			if ( fn.length > 1 ) {
2069
				args = [ pseudo, pseudo, "", argument ];
2070
				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2071
					markFunction( function( seed, matches ) {
2072
						var idx,
2073
							matched = fn( seed, argument ),
2074
							i = matched.length;
2075
						while ( i-- ) {
2076
							idx = indexOf( seed, matched[ i ] );
2077
							seed[ idx ] = !( matches[ idx ] = matched[ i ] );
2078
						}
2079
					} ) :
2080
					function( elem ) {
2081
						return fn( elem, 0, args );
2082
					};
2083
			}
2084

2085
			return fn;
2086
		}
2087
	},
2088

2089
	pseudos: {
2090

2091
		// Potentially complex pseudos
2092
		"not": markFunction( function( selector ) {
2093

2094
			// Trim the selector passed to compile
2095
			// to avoid treating leading and trailing
2096
			// spaces as combinators
2097
			var input = [],
2098
				results = [],
2099
				matcher = compile( selector.replace( rtrim, "$1" ) );
2100

2101
			return matcher[ expando ] ?
2102
				markFunction( function( seed, matches, _context, xml ) {
2103
					var elem,
2104
						unmatched = matcher( seed, null, xml, [] ),
2105
						i = seed.length;
2106

2107
					// Match elements unmatched by `matcher`
2108
					while ( i-- ) {
2109
						if ( ( elem = unmatched[ i ] ) ) {
2110
							seed[ i ] = !( matches[ i ] = elem );
2111
						}
2112
					}
2113
				} ) :
2114
				function( elem, _context, xml ) {
2115
					input[ 0 ] = elem;
2116
					matcher( input, null, xml, results );
2117

2118
					// Don't keep the element (issue #299)
2119
					input[ 0 ] = null;
2120
					return !results.pop();
2121
				};
2122
		} ),
2123

2124
		"has": markFunction( function( selector ) {
2125
			return function( elem ) {
2126
				return Sizzle( selector, elem ).length > 0;
2127
			};
2128
		} ),
2129

2130
		"contains": markFunction( function( text ) {
2131
			text = text.replace( runescape, funescape );
2132
			return function( elem ) {
2133
				return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
2134
			};
2135
		} ),
2136

2137
		// "Whether an element is represented by a :lang() selector
2138
		// is based solely on the element's language value
2139
		// being equal to the identifier C,
2140
		// or beginning with the identifier C immediately followed by "-".
2141
		// The matching of C against the element's language value is performed case-insensitively.
2142
		// The identifier C does not have to be a valid language name."
2143
		// http://www.w3.org/TR/selectors/#lang-pseudo
2144
		"lang": markFunction( function( lang ) {
2145

2146
			// lang value must be a valid identifier
2147
			if ( !ridentifier.test( lang || "" ) ) {
2148
				Sizzle.error( "unsupported lang: " + lang );
2149
			}
2150
			lang = lang.replace( runescape, funescape ).toLowerCase();
2151
			return function( elem ) {
2152
				var elemLang;
2153
				do {
2154
					if ( ( elemLang = documentIsHTML ?
2155
						elem.lang :
2156
						elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
2157

2158
						elemLang = elemLang.toLowerCase();
2159
						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2160
					}
2161
				} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
2162
				return false;
2163
			};
2164
		} ),
2165

2166
		// Miscellaneous
2167
		"target": function( elem ) {
2168
			var hash = window.location && window.location.hash;
2169
			return hash && hash.slice( 1 ) === elem.id;
2170
		},
2171

2172
		"root": function( elem ) {
2173
			return elem === docElem;
2174
		},
2175

2176
		"focus": function( elem ) {
2177
			return elem === document.activeElement &&
2178
				( !document.hasFocus || document.hasFocus() ) &&
2179
				!!( elem.type || elem.href || ~elem.tabIndex );
2180
		},
2181

2182
		// Boolean properties
2183
		"enabled": createDisabledPseudo( false ),
2184
		"disabled": createDisabledPseudo( true ),
2185

2186
		"checked": function( elem ) {
2187

2188
			// In CSS3, :checked should return both checked and selected elements
2189
			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2190
			var nodeName = elem.nodeName.toLowerCase();
2191
			return ( nodeName === "input" && !!elem.checked ) ||
2192
				( nodeName === "option" && !!elem.selected );
2193
		},
2194

2195
		"selected": function( elem ) {
2196

2197
			// Accessing this property makes selected-by-default
2198
			// options in Safari work properly
2199
			if ( elem.parentNode ) {
2200
				// eslint-disable-next-line no-unused-expressions
2201
				elem.parentNode.selectedIndex;
2202
			}
2203

2204
			return elem.selected === true;
2205
		},
2206

2207
		// Contents
2208
		"empty": function( elem ) {
2209

2210
			// http://www.w3.org/TR/selectors/#empty-pseudo
2211
			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2212
			//   but not by others (comment: 8; processing instruction: 7; etc.)
2213
			// nodeType < 6 works because attributes (2) do not appear as children
2214
			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2215
				if ( elem.nodeType < 6 ) {
2216
					return false;
2217
				}
2218
			}
2219
			return true;
2220
		},
2221

2222
		"parent": function( elem ) {
2223
			return !Expr.pseudos[ "empty" ]( elem );
2224
		},
2225

2226
		// Element/input types
2227
		"header": function( elem ) {
2228
			return rheader.test( elem.nodeName );
2229
		},
2230

2231
		"input": function( elem ) {
2232
			return rinputs.test( elem.nodeName );
2233
		},
2234

2235
		"button": function( elem ) {
2236
			var name = elem.nodeName.toLowerCase();
2237
			return name === "input" && elem.type === "button" || name === "button";
2238
		},
2239

2240
		"text": function( elem ) {
2241
			var attr;
2242
			return elem.nodeName.toLowerCase() === "input" &&
2243
				elem.type === "text" &&
2244

2245
				// Support: IE<8
2246
				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2247
				( ( attr = elem.getAttribute( "type" ) ) == null ||
2248
					attr.toLowerCase() === "text" );
2249
		},
2250

2251
		// Position-in-collection
2252
		"first": createPositionalPseudo( function() {
2253
			return [ 0 ];
2254
		} ),
2255

2256
		"last": createPositionalPseudo( function( _matchIndexes, length ) {
2257
			return [ length - 1 ];
2258
		} ),
2259

2260
		"eq": createPositionalPseudo( function( _matchIndexes, length, argument ) {
2261
			return [ argument < 0 ? argument + length : argument ];
2262
		} ),
2263

2264
		"even": createPositionalPseudo( function( matchIndexes, length ) {
2265
			var i = 0;
2266
			for ( ; i < length; i += 2 ) {
2267
				matchIndexes.push( i );
2268
			}
2269
			return matchIndexes;
2270
		} ),
2271

2272
		"odd": createPositionalPseudo( function( matchIndexes, length ) {
2273
			var i = 1;
2274
			for ( ; i < length; i += 2 ) {
2275
				matchIndexes.push( i );
2276
			}
2277
			return matchIndexes;
2278
		} ),
2279

2280
		"lt": createPositionalPseudo( function( matchIndexes, length, argument ) {
2281
			var i = argument < 0 ?
2282
				argument + length :
2283
				argument > length ?
2284
					length :
2285
					argument;
2286
			for ( ; --i >= 0; ) {
2287
				matchIndexes.push( i );
2288
			}
2289
			return matchIndexes;
2290
		} ),
2291

2292
		"gt": createPositionalPseudo( function( matchIndexes, length, argument ) {
2293
			var i = argument < 0 ? argument + length : argument;
2294
			for ( ; ++i < length; ) {
2295
				matchIndexes.push( i );
2296
			}
2297
			return matchIndexes;
2298
		} )
2299
	}
2300
};
2301

2302
Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ];
2303

2304
// Add button/input type pseudos
2305
for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2306
	Expr.pseudos[ i ] = createInputPseudo( i );
2307
}
2308
for ( i in { submit: true, reset: true } ) {
2309
	Expr.pseudos[ i ] = createButtonPseudo( i );
2310
}
2311

2312
// Easy API for creating new setFilters
2313
function setFilters() {}
2314
setFilters.prototype = Expr.filters = Expr.pseudos;
2315
Expr.setFilters = new setFilters();
2316

2317
tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2318
	var matched, match, tokens, type,
2319
		soFar, groups, preFilters,
2320
		cached = tokenCache[ selector + " " ];
2321

2322
	if ( cached ) {
2323
		return parseOnly ? 0 : cached.slice( 0 );
2324
	}
2325

2326
	soFar = selector;
2327
	groups = [];
2328
	preFilters = Expr.preFilter;
2329

2330
	while ( soFar ) {
2331

2332
		// Comma and first run
2333
		if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
2334
			if ( match ) {
2335

2336
				// Don't consume trailing commas as valid
2337
				soFar = soFar.slice( match[ 0 ].length ) || soFar;
2338
			}
2339
			groups.push( ( tokens = [] ) );
2340
		}
2341

2342
		matched = false;
2343

2344
		// Combinators
2345
		if ( ( match = rcombinators.exec( soFar ) ) ) {
2346
			matched = match.shift();
2347
			tokens.push( {
2348
				value: matched,
2349

2350
				// Cast descendant combinators to space
2351
				type: match[ 0 ].replace( rtrim, " " )
2352
			} );
2353
			soFar = soFar.slice( matched.length );
2354
		}
2355

2356
		// Filters
2357
		for ( type in Expr.filter ) {
2358
			if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
2359
				( match = preFilters[ type ]( match ) ) ) ) {
2360
				matched = match.shift();
2361
				tokens.push( {
2362
					value: matched,
2363
					type: type,
2364
					matches: match
2365
				} );
2366
				soFar = soFar.slice( matched.length );
2367
			}
2368
		}
2369

2370
		if ( !matched ) {
2371
			break;
2372
		}
2373
	}
2374

2375
	// Return the length of the invalid excess
2376
	// if we're just parsing
2377
	// Otherwise, throw an error or return tokens
2378
	return parseOnly ?
2379
		soFar.length :
2380
		soFar ?
2381
			Sizzle.error( selector ) :
2382

2383
			// Cache the tokens
2384
			tokenCache( selector, groups ).slice( 0 );
2385
};
2386

2387
function toSelector( tokens ) {
2388
	var i = 0,
2389
		len = tokens.length,
2390
		selector = "";
2391
	for ( ; i < len; i++ ) {
2392
		selector += tokens[ i ].value;
2393
	}
2394
	return selector;
2395
}
2396

2397
function addCombinator( matcher, combinator, base ) {
2398
	var dir = combinator.dir,
2399
		skip = combinator.next,
2400
		key = skip || dir,
2401
		checkNonElements = base && key === "parentNode",
2402
		doneName = done++;
2403

2404
	return combinator.first ?
2405

2406
		// Check against closest ancestor/preceding element
2407
		function( elem, context, xml ) {
2408
			while ( ( elem = elem[ dir ] ) ) {
2409
				if ( elem.nodeType === 1 || checkNonElements ) {
2410
					return matcher( elem, context, xml );
2411
				}
2412
			}
2413
			return false;
2414
		} :
2415

2416
		// Check against all ancestor/preceding elements
2417
		function( elem, context, xml ) {
2418
			var oldCache, uniqueCache, outerCache,
2419
				newCache = [ dirruns, doneName ];
2420

2421
			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2422
			if ( xml ) {
2423
				while ( ( elem = elem[ dir ] ) ) {
2424
					if ( elem.nodeType === 1 || checkNonElements ) {
2425
						if ( matcher( elem, context, xml ) ) {
2426
							return true;
2427
						}
2428
					}
2429
				}
2430
			} else {
2431
				while ( ( elem = elem[ dir ] ) ) {
2432
					if ( elem.nodeType === 1 || checkNonElements ) {
2433
						outerCache = elem[ expando ] || ( elem[ expando ] = {} );
2434

2435
						// Support: IE <9 only
2436
						// Defend against cloned attroperties (jQuery gh-1709)
2437
						uniqueCache = outerCache[ elem.uniqueID ] ||
2438
							( outerCache[ elem.uniqueID ] = {} );
2439

2440
						if ( skip && skip === elem.nodeName.toLowerCase() ) {
2441
							elem = elem[ dir ] || elem;
2442
						} else if ( ( oldCache = uniqueCache[ key ] ) &&
2443
							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2444

2445
							// Assign to newCache so results back-propagate to previous elements
2446
							return ( newCache[ 2 ] = oldCache[ 2 ] );
2447
						} else {
2448

2449
							// Reuse newcache so results back-propagate to previous elements
2450
							uniqueCache[ key ] = newCache;
2451

2452
							// A match means we're done; a fail means we have to keep checking
2453
							if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
2454
								return true;
2455
							}
2456
						}
2457
					}
2458
				}
2459
			}
2460
			return false;
2461
		};
2462
}
2463

2464
function elementMatcher( matchers ) {
2465
	return matchers.length > 1 ?
2466
		function( elem, context, xml ) {
2467
			var i = matchers.length;
2468
			while ( i-- ) {
2469
				if ( !matchers[ i ]( elem, context, xml ) ) {
2470
					return false;
2471
				}
2472
			}
2473
			return true;
2474
		} :
2475
		matchers[ 0 ];
2476
}
2477

2478
function multipleContexts( selector, contexts, results ) {
2479
	var i = 0,
2480
		len = contexts.length;
2481
	for ( ; i < len; i++ ) {
2482
		Sizzle( selector, contexts[ i ], results );
2483
	}
2484
	return results;
2485
}
2486

2487
function condense( unmatched, map, filter, context, xml ) {
2488
	var elem,
2489
		newUnmatched = [],
2490
		i = 0,
2491
		len = unmatched.length,
2492
		mapped = map != null;
2493

2494
	for ( ; i < len; i++ ) {
2495
		if ( ( elem = unmatched[ i ] ) ) {
2496
			if ( !filter || filter( elem, context, xml ) ) {
2497
				newUnmatched.push( elem );
2498
				if ( mapped ) {
2499
					map.push( i );
2500
				}
2501
			}
2502
		}
2503
	}
2504

2505
	return newUnmatched;
2506
}
2507

2508
function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2509
	if ( postFilter && !postFilter[ expando ] ) {
2510
		postFilter = setMatcher( postFilter );
2511
	}
2512
	if ( postFinder && !postFinder[ expando ] ) {
2513
		postFinder = setMatcher( postFinder, postSelector );
2514
	}
2515
	return markFunction( function( seed, results, context, xml ) {
2516
		var temp, i, elem,
2517
			preMap = [],
2518
			postMap = [],
2519
			preexisting = results.length,
2520

2521
			// Get initial elements from seed or context
2522
			elems = seed || multipleContexts(
2523
				selector || "*",
2524
				context.nodeType ? [ context ] : context,
2525
				[]
2526
			),
2527

2528
			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2529
			matcherIn = preFilter && ( seed || !selector ) ?
2530
				condense( elems, preMap, preFilter, context, xml ) :
2531
				elems,
2532

2533
			matcherOut = matcher ?
2534

2535
				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2536
				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2537

2538
					// ...intermediate processing is necessary
2539
					[] :
2540

2541
					// ...otherwise use results directly
2542
					results :
2543
				matcherIn;
2544

2545
		// Find primary matches
2546
		if ( matcher ) {
2547
			matcher( matcherIn, matcherOut, context, xml );
2548
		}
2549

2550
		// Apply postFilter
2551
		if ( postFilter ) {
2552
			temp = condense( matcherOut, postMap );
2553
			postFilter( temp, [], context, xml );
2554

2555
			// Un-match failing elements by moving them back to matcherIn
2556
			i = temp.length;
2557
			while ( i-- ) {
2558
				if ( ( elem = temp[ i ] ) ) {
2559
					matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
2560
				}
2561
			}
2562
		}
2563

2564
		if ( seed ) {
2565
			if ( postFinder || preFilter ) {
2566
				if ( postFinder ) {
2567

2568
					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2569
					temp = [];
2570
					i = matcherOut.length;
2571
					while ( i-- ) {
2572
						if ( ( elem = matcherOut[ i ] ) ) {
2573

2574
							// Restore matcherIn since elem is not yet a final match
2575
							temp.push( ( matcherIn[ i ] = elem ) );
2576
						}
2577
					}
2578
					postFinder( null, ( matcherOut = [] ), temp, xml );
2579
				}
2580

2581
				// Move matched elements from seed to results to keep them synchronized
2582
				i = matcherOut.length;
2583
				while ( i-- ) {
2584
					if ( ( elem = matcherOut[ i ] ) &&
2585
						( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {
2586

2587
						seed[ temp ] = !( results[ temp ] = elem );
2588
					}
2589
				}
2590
			}
2591

2592
		// Add elements to results, through postFinder if defined
2593
		} else {
2594
			matcherOut = condense(
2595
				matcherOut === results ?
2596
					matcherOut.splice( preexisting, matcherOut.length ) :
2597
					matcherOut
2598
			);
2599
			if ( postFinder ) {
2600
				postFinder( null, results, matcherOut, xml );
2601
			} else {
2602
				push.apply( results, matcherOut );
2603
			}
2604
		}
2605
	} );
2606
}
2607

2608
function matcherFromTokens( tokens ) {
2609
	var checkContext, matcher, j,
2610
		len = tokens.length,
2611
		leadingRelative = Expr.relative[ tokens[ 0 ].type ],
2612
		implicitRelative = leadingRelative || Expr.relative[ " " ],
2613
		i = leadingRelative ? 1 : 0,
2614

2615
		// The foundational matcher ensures that elements are reachable from top-level context(s)
2616
		matchContext = addCombinator( function( elem ) {
2617
			return elem === checkContext;
2618
		}, implicitRelative, true ),
2619
		matchAnyContext = addCombinator( function( elem ) {
2620
			return indexOf( checkContext, elem ) > -1;
2621
		}, implicitRelative, true ),
2622
		matchers = [ function( elem, context, xml ) {
2623
			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2624
				( checkContext = context ).nodeType ?
2625
					matchContext( elem, context, xml ) :
2626
					matchAnyContext( elem, context, xml ) );
2627

2628
			// Avoid hanging onto element (issue #299)
2629
			checkContext = null;
2630
			return ret;
2631
		} ];
2632

2633
	for ( ; i < len; i++ ) {
2634
		if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
2635
			matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
2636
		} else {
2637
			matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
2638

2639
			// Return special upon seeing a positional matcher
2640
			if ( matcher[ expando ] ) {
2641

2642
				// Find the next relative operator (if any) for proper handling
2643
				j = ++i;
2644
				for ( ; j < len; j++ ) {
2645
					if ( Expr.relative[ tokens[ j ].type ] ) {
2646
						break;
2647
					}
2648
				}
2649
				return setMatcher(
2650
					i > 1 && elementMatcher( matchers ),
2651
					i > 1 && toSelector(
2652

2653
					// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2654
					tokens
2655
						.slice( 0, i - 1 )
2656
						.concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
2657
					).replace( rtrim, "$1" ),
2658
					matcher,
2659
					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2660
					j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
2661
					j < len && toSelector( tokens )
2662
				);
2663
			}
2664
			matchers.push( matcher );
2665
		}
2666
	}
2667

2668
	return elementMatcher( matchers );
2669
}
2670

2671
function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2672
	var bySet = setMatchers.length > 0,
2673
		byElement = elementMatchers.length > 0,
2674
		superMatcher = function( seed, context, xml, results, outermost ) {
2675
			var elem, j, matcher,
2676
				matchedCount = 0,
2677
				i = "0",
2678
				unmatched = seed && [],
2679
				setMatched = [],
2680
				contextBackup = outermostContext,
2681

2682
				// We must always have either seed elements or outermost context
2683
				elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ),
2684

2685
				// Use integer dirruns iff this is the outermost matcher
2686
				dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
2687
				len = elems.length;
2688

2689
			if ( outermost ) {
2690

2691
				// Support: IE 11+, Edge 17 - 18+
2692
				// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2693
				// two documents; shallow comparisons work.
2694
				// eslint-disable-next-line eqeqeq
2695
				outermostContext = context == document || context || outermost;
2696
			}
2697

2698
			// Add elements passing elementMatchers directly to results
2699
			// Support: IE<9, Safari
2700
			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2701
			for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
2702
				if ( byElement && elem ) {
2703
					j = 0;
2704

2705
					// Support: IE 11+, Edge 17 - 18+
2706
					// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2707
					// two documents; shallow comparisons work.
2708
					// eslint-disable-next-line eqeqeq
2709
					if ( !context && elem.ownerDocument != document ) {
2710
						setDocument( elem );
2711
						xml = !documentIsHTML;
2712
					}
2713
					while ( ( matcher = elementMatchers[ j++ ] ) ) {
2714
						if ( matcher( elem, context || document, xml ) ) {
2715
							results.push( elem );
2716
							break;
2717
						}
2718
					}
2719
					if ( outermost ) {
2720
						dirruns = dirrunsUnique;
2721
					}
2722
				}
2723

2724
				// Track unmatched elements for set filters
2725
				if ( bySet ) {
2726

2727
					// They will have gone through all possible matchers
2728
					if ( ( elem = !matcher && elem ) ) {
2729
						matchedCount--;
2730
					}
2731

2732
					// Lengthen the array for every element, matched or not
2733
					if ( seed ) {
2734
						unmatched.push( elem );
2735
					}
2736
				}
2737
			}
2738

2739
			// `i` is now the count of elements visited above, and adding it to `matchedCount`
2740
			// makes the latter nonnegative.
2741
			matchedCount += i;
2742

2743
			// Apply set filters to unmatched elements
2744
			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2745
			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2746
			// no element matchers and no seed.
2747
			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2748
			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2749
			// numerically zero.
2750
			if ( bySet && i !== matchedCount ) {
2751
				j = 0;
2752
				while ( ( matcher = setMatchers[ j++ ] ) ) {
2753
					matcher( unmatched, setMatched, context, xml );
2754
				}
2755

2756
				if ( seed ) {
2757

2758
					// Reintegrate element matches to eliminate the need for sorting
2759
					if ( matchedCount > 0 ) {
2760
						while ( i-- ) {
2761
							if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
2762
								setMatched[ i ] = pop.call( results );
2763
							}
2764
						}
2765
					}
2766

2767
					// Discard index placeholder values to get only actual matches
2768
					setMatched = condense( setMatched );
2769
				}
2770

2771
				// Add matches to results
2772
				push.apply( results, setMatched );
2773

2774
				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2775
				if ( outermost && !seed && setMatched.length > 0 &&
2776
					( matchedCount + setMatchers.length ) > 1 ) {
2777

2778
					Sizzle.uniqueSort( results );
2779
				}
2780
			}
2781

2782
			// Override manipulation of globals by nested matchers
2783
			if ( outermost ) {
2784
				dirruns = dirrunsUnique;
2785
				outermostContext = contextBackup;
2786
			}
2787

2788
			return unmatched;
2789
		};
2790

2791
	return bySet ?
2792
		markFunction( superMatcher ) :
2793
		superMatcher;
2794
}
2795

2796
compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2797
	var i,
2798
		setMatchers = [],
2799
		elementMatchers = [],
2800
		cached = compilerCache[ selector + " " ];
2801

2802
	if ( !cached ) {
2803

2804
		// Generate a function of recursive functions that can be used to check each element
2805
		if ( !match ) {
2806
			match = tokenize( selector );
2807
		}
2808
		i = match.length;
2809
		while ( i-- ) {
2810
			cached = matcherFromTokens( match[ i ] );
2811
			if ( cached[ expando ] ) {
2812
				setMatchers.push( cached );
2813
			} else {
2814
				elementMatchers.push( cached );
2815
			}
2816
		}
2817

2818
		// Cache the compiled function
2819
		cached = compilerCache(
2820
			selector,
2821
			matcherFromGroupMatchers( elementMatchers, setMatchers )
2822
		);
2823

2824
		// Save selector and tokenization
2825
		cached.selector = selector;
2826
	}
2827
	return cached;
2828
};
2829

2830
/**
2831
 * A low-level selection function that works with Sizzle's compiled
2832
 *  selector functions
2833
 * @param {String|Function} selector A selector or a pre-compiled
2834
 *  selector function built with Sizzle.compile
2835
 * @param {Element} context
2836
 * @param {Array} [results]
2837
 * @param {Array} [seed] A set of elements to match against
2838
 */
2839
select = Sizzle.select = function( selector, context, results, seed ) {
2840
	var i, tokens, token, type, find,
2841
		compiled = typeof selector === "function" && selector,
2842
		match = !seed && tokenize( ( selector = compiled.selector || selector ) );
2843

2844
	results = results || [];
2845

2846
	// Try to minimize operations if there is only one selector in the list and no seed
2847
	// (the latter of which guarantees us context)
2848
	if ( match.length === 1 ) {
2849

2850
		// Reduce context if the leading compound selector is an ID
2851
		tokens = match[ 0 ] = match[ 0 ].slice( 0 );
2852
		if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
2853
			context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
2854

2855
			context = ( Expr.find[ "ID" ]( token.matches[ 0 ]
2856
				.replace( runescape, funescape ), context ) || [] )[ 0 ];
2857
			if ( !context ) {
2858
				return results;
2859

2860
			// Precompiled matchers will still verify ancestry, so step up a level
2861
			} else if ( compiled ) {
2862
				context = context.parentNode;
2863
			}
2864

2865
			selector = selector.slice( tokens.shift().value.length );
2866
		}
2867

2868
		// Fetch a seed set for right-to-left matching
2869
		i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length;
2870
		while ( i-- ) {
2871
			token = tokens[ i ];
2872

2873
			// Abort if we hit a combinator
2874
			if ( Expr.relative[ ( type = token.type ) ] ) {
2875
				break;
2876
			}
2877
			if ( ( find = Expr.find[ type ] ) ) {
2878

2879
				// Search, expanding context for leading sibling combinators
2880
				if ( ( seed = find(
2881
					token.matches[ 0 ].replace( runescape, funescape ),
2882
					rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||
2883
						context
2884
				) ) ) {
2885

2886
					// If seed is empty or no tokens remain, we can return early
2887
					tokens.splice( i, 1 );
2888
					selector = seed.length && toSelector( tokens );
2889
					if ( !selector ) {
2890
						push.apply( results, seed );
2891
						return results;
2892
					}
2893

2894
					break;
2895
				}
2896
			}
2897
		}
2898
	}
2899

2900
	// Compile and execute a filtering function if one is not provided
2901
	// Provide `match` to avoid retokenization if we modified the selector above
2902
	( compiled || compile( selector, match ) )(
2903
		seed,
2904
		context,
2905
		!documentIsHTML,
2906
		results,
2907
		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2908
	);
2909
	return results;
2910
};
2911

2912
// One-time assignments
2913

2914
// Sort stability
2915
support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
2916

2917
// Support: Chrome 14-35+
2918
// Always assume duplicates if they aren't passed to the comparison function
2919
support.detectDuplicates = !!hasDuplicate;
2920

2921
// Initialize against the default document
2922
setDocument();
2923

2924
// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2925
// Detached nodes confoundingly follow *each other*
2926
support.sortDetached = assert( function( el ) {
2927

2928
	// Should return 1, but returns 4 (following)
2929
	return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
2930
} );
2931

2932
// Support: IE<8
2933
// Prevent attribute/property "interpolation"
2934
// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2935
if ( !assert( function( el ) {
2936
	el.innerHTML = "<a href='#'></a>";
2937
	return el.firstChild.getAttribute( "href" ) === "#";
2938
} ) ) {
2939
	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2940
		if ( !isXML ) {
2941
			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2942
		}
2943
	} );
2944
}
2945

2946
// Support: IE<9
2947
// Use defaultValue in place of getAttribute("value")
2948
if ( !support.attributes || !assert( function( el ) {
2949
	el.innerHTML = "<input/>";
2950
	el.firstChild.setAttribute( "value", "" );
2951
	return el.firstChild.getAttribute( "value" ) === "";
2952
} ) ) {
2953
	addHandle( "value", function( elem, _name, isXML ) {
2954
		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2955
			return elem.defaultValue;
2956
		}
2957
	} );
2958
}
2959

2960
// Support: IE<9
2961
// Use getAttributeNode to fetch booleans when getAttribute lies
2962
if ( !assert( function( el ) {
2963
	return el.getAttribute( "disabled" ) == null;
2964
} ) ) {
2965
	addHandle( booleans, function( elem, name, isXML ) {
2966
		var val;
2967
		if ( !isXML ) {
2968
			return elem[ name ] === true ? name.toLowerCase() :
2969
				( val = elem.getAttributeNode( name ) ) && val.specified ?
2970
					val.value :
2971
					null;
2972
		}
2973
	} );
2974
}
2975

2976
return Sizzle;
2977

2978
} )( window );
2979

2980

2981

2982
jQuery.find = Sizzle;
2983
jQuery.expr = Sizzle.selectors;
2984

2985
// Deprecated
2986
jQuery.expr[ ":" ] = jQuery.expr.pseudos;
2987
jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2988
jQuery.text = Sizzle.getText;
2989
jQuery.isXMLDoc = Sizzle.isXML;
2990
jQuery.contains = Sizzle.contains;
2991
jQuery.escapeSelector = Sizzle.escape;
2992

2993

2994

2995

2996
var dir = function( elem, dir, until ) {
2997
	var matched = [],
2998
		truncate = until !== undefined;
2999

3000
	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
3001
		if ( elem.nodeType === 1 ) {
3002
			if ( truncate && jQuery( elem ).is( until ) ) {
3003
				break;
3004
			}
3005
			matched.push( elem );
3006
		}
3007
	}
3008
	return matched;
3009
};
3010

3011

3012
var siblings = function( n, elem ) {
3013
	var matched = [];
3014

3015
	for ( ; n; n = n.nextSibling ) {
3016
		if ( n.nodeType === 1 && n !== elem ) {
3017
			matched.push( n );
3018
		}
3019
	}
3020

3021
	return matched;
3022
};
3023

3024

3025
var rneedsContext = jQuery.expr.match.needsContext;
3026

3027

3028

3029
function nodeName( elem, name ) {
3030

3031
	return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
3032

3033
}
3034
var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
3035

3036

3037

3038
// Implement the identical functionality for filter and not
3039
function winnow( elements, qualifier, not ) {
3040
	if ( isFunction( qualifier ) ) {
3041
		return jQuery.grep( elements, function( elem, i ) {
3042
			return !!qualifier.call( elem, i, elem ) !== not;
3043
		} );
3044
	}
3045

3046
	// Single element
3047
	if ( qualifier.nodeType ) {
3048
		return jQuery.grep( elements, function( elem ) {
3049
			return ( elem === qualifier ) !== not;
3050
		} );
3051
	}
3052

3053
	// Arraylike of elements (jQuery, arguments, Array)
3054
	if ( typeof qualifier !== "string" ) {
3055
		return jQuery.grep( elements, function( elem ) {
3056
			return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
3057
		} );
3058
	}
3059

3060
	// Filtered directly for both simple and complex selectors
3061
	return jQuery.filter( qualifier, elements, not );
3062
}
3063

3064
jQuery.filter = function( expr, elems, not ) {
3065
	var elem = elems[ 0 ];
3066

3067
	if ( not ) {
3068
		expr = ":not(" + expr + ")";
3069
	}
3070

3071
	if ( elems.length === 1 && elem.nodeType === 1 ) {
3072
		return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
3073
	}
3074

3075
	return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
3076
		return elem.nodeType === 1;
3077
	} ) );
3078
};
3079

3080
jQuery.fn.extend( {
3081
	find: function( selector ) {
3082
		var i, ret,
3083
			len = this.length,
3084
			self = this;
3085

3086
		if ( typeof selector !== "string" ) {
3087
			return this.pushStack( jQuery( selector ).filter( function() {
3088
				for ( i = 0; i < len; i++ ) {
3089
					if ( jQuery.contains( self[ i ], this ) ) {
3090
						return true;
3091
					}
3092
				}
3093
			} ) );
3094
		}
3095

3096
		ret = this.pushStack( [] );
3097

3098
		for ( i = 0; i < len; i++ ) {
3099
			jQuery.find( selector, self[ i ], ret );
3100
		}
3101

3102
		return len > 1 ? jQuery.uniqueSort( ret ) : ret;
3103
	},
3104
	filter: function( selector ) {
3105
		return this.pushStack( winnow( this, selector || [], false ) );
3106
	},
3107
	not: function( selector ) {
3108
		return this.pushStack( winnow( this, selector || [], true ) );
3109
	},
3110
	is: function( selector ) {
3111
		return !!winnow(
3112
			this,
3113

3114
			// If this is a positional/relative selector, check membership in the returned set
3115
			// so $("p:first").is("p:last") won't return true for a doc with two "p".
3116
			typeof selector === "string" && rneedsContext.test( selector ) ?
3117
				jQuery( selector ) :
3118
				selector || [],
3119
			false
3120
		).length;
3121
	}
3122
} );
3123

3124

3125
// Initialize a jQuery object
3126

3127

3128
// A central reference to the root jQuery(document)
3129
var rootjQuery,
3130

3131
	// A simple way to check for HTML strings
3132
	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
3133
	// Strict HTML recognition (#11290: must start with <)
3134
	// Shortcut simple #id case for speed
3135
	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
3136

3137
	init = jQuery.fn.init = function( selector, context, root ) {
3138
		var match, elem;
3139

3140
		// HANDLE: $(""), $(null), $(undefined), $(false)
3141
		if ( !selector ) {
3142
			return this;
3143
		}
3144

3145
		// Method init() accepts an alternate rootjQuery
3146
		// so migrate can support jQuery.sub (gh-2101)
3147
		root = root || rootjQuery;
3148

3149
		// Handle HTML strings
3150
		if ( typeof selector === "string" ) {
3151
			if ( selector[ 0 ] === "<" &&
3152
				selector[ selector.length - 1 ] === ">" &&
3153
				selector.length >= 3 ) {
3154

3155
				// Assume that strings that start and end with <> are HTML and skip the regex check
3156
				match = [ null, selector, null ];
3157

3158
			} else {
3159
				match = rquickExpr.exec( selector );
3160
			}
3161

3162
			// Match html or make sure no context is specified for #id
3163
			if ( match && ( match[ 1 ] || !context ) ) {
3164

3165
				// HANDLE: $(html) -> $(array)
3166
				if ( match[ 1 ] ) {
3167
					context = context instanceof jQuery ? context[ 0 ] : context;
3168

3169
					// Option to run scripts is true for back-compat
3170
					// Intentionally let the error be thrown if parseHTML is not present
3171
					jQuery.merge( this, jQuery.parseHTML(
3172
						match[ 1 ],
3173
						context && context.nodeType ? context.ownerDocument || context : document,
3174
						true
3175
					) );
3176

3177
					// HANDLE: $(html, props)
3178
					if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
3179
						for ( match in context ) {
3180

3181
							// Properties of context are called as methods if possible
3182
							if ( isFunction( this[ match ] ) ) {
3183
								this[ match ]( context[ match ] );
3184

3185
							// ...and otherwise set as attributes
3186
							} else {
3187
								this.attr( match, context[ match ] );
3188
							}
3189
						}
3190
					}
3191

3192
					return this;
3193

3194
				// HANDLE: $(#id)
3195
				} else {
3196
					elem = document.getElementById( match[ 2 ] );
3197

3198
					if ( elem ) {
3199

3200
						// Inject the element directly into the jQuery object
3201
						this[ 0 ] = elem;
3202
						this.length = 1;
3203
					}
3204
					return this;
3205
				}
3206

3207
			// HANDLE: $(expr, $(...))
3208
			} else if ( !context || context.jquery ) {
3209
				return ( context || root ).find( selector );
3210

3211
			// HANDLE: $(expr, context)
3212
			// (which is just equivalent to: $(context).find(expr)
3213
			} else {
3214
				return this.constructor( context ).find( selector );
3215
			}
3216

3217
		// HANDLE: $(DOMElement)
3218
		} else if ( selector.nodeType ) {
3219
			this[ 0 ] = selector;
3220
			this.length = 1;
3221
			return this;
3222

3223
		// HANDLE: $(function)
3224
		// Shortcut for document ready
3225
		} else if ( isFunction( selector ) ) {
3226
			return root.ready !== undefined ?
3227
				root.ready( selector ) :
3228

3229
				// Execute immediately if ready is not present
3230
				selector( jQuery );
3231
		}
3232

3233
		return jQuery.makeArray( selector, this );
3234
	};
3235

3236
// Give the init function the jQuery prototype for later instantiation
3237
init.prototype = jQuery.fn;
3238

3239
// Initialize central reference
3240
rootjQuery = jQuery( document );
3241

3242

3243
var rparentsprev = /^(?:parents|prev(?:Until|All))/,
3244

3245
	// Methods guaranteed to produce a unique set when starting from a unique set
3246
	guaranteedUnique = {
3247
		children: true,
3248
		contents: true,
3249
		next: true,
3250
		prev: true
3251
	};
3252

3253
jQuery.fn.extend( {
3254
	has: function( target ) {
3255
		var targets = jQuery( target, this ),
3256
			l = targets.length;
3257

3258
		return this.filter( function() {
3259
			var i = 0;
3260
			for ( ; i < l; i++ ) {
3261
				if ( jQuery.contains( this, targets[ i ] ) ) {
3262
					return true;
3263
				}
3264
			}
3265
		} );
3266
	},
3267

3268
	closest: function( selectors, context ) {
3269
		var cur,
3270
			i = 0,
3271
			l = this.length,
3272
			matched = [],
3273
			targets = typeof selectors !== "string" && jQuery( selectors );
3274

3275
		// Positional selectors never match, since there's no _selection_ context
3276
		if ( !rneedsContext.test( selectors ) ) {
3277
			for ( ; i < l; i++ ) {
3278
				for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
3279

3280
					// Always skip document fragments
3281
					if ( cur.nodeType < 11 && ( targets ?
3282
						targets.index( cur ) > -1 :
3283

3284
						// Don't pass non-elements to Sizzle
3285
						cur.nodeType === 1 &&
3286
							jQuery.find.matchesSelector( cur, selectors ) ) ) {
3287

3288
						matched.push( cur );
3289
						break;
3290
					}
3291
				}
3292
			}
3293
		}
3294

3295
		return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
3296
	},
3297

3298
	// Determine the position of an element within the set
3299
	index: function( elem ) {
3300

3301
		// No argument, return index in parent
3302
		if ( !elem ) {
3303
			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
3304
		}
3305

3306
		// Index in selector
3307
		if ( typeof elem === "string" ) {
3308
			return indexOf.call( jQuery( elem ), this[ 0 ] );
3309
		}
3310

3311
		// Locate the position of the desired element
3312
		return indexOf.call( this,
3313

3314
			// If it receives a jQuery object, the first element is used
3315
			elem.jquery ? elem[ 0 ] : elem
3316
		);
3317
	},
3318

3319
	add: function( selector, context ) {
3320
		return this.pushStack(
3321
			jQuery.uniqueSort(
3322
				jQuery.merge( this.get(), jQuery( selector, context ) )
3323
			)
3324
		);
3325
	},
3326

3327
	addBack: function( selector ) {
3328
		return this.add( selector == null ?
3329
			this.prevObject : this.prevObject.filter( selector )
3330
		);
3331
	}
3332
} );
3333

3334
function sibling( cur, dir ) {
3335
	while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
3336
	return cur;
3337
}
3338

3339
jQuery.each( {
3340
	parent: function( elem ) {
3341
		var parent = elem.parentNode;
3342
		return parent && parent.nodeType !== 11 ? parent : null;
3343
	},
3344
	parents: function( elem ) {
3345
		return dir( elem, "parentNode" );
3346
	},
3347
	parentsUntil: function( elem, _i, until ) {
3348
		return dir( elem, "parentNode", until );
3349
	},
3350
	next: function( elem ) {
3351
		return sibling( elem, "nextSibling" );
3352
	},
3353
	prev: function( elem ) {
3354
		return sibling( elem, "previousSibling" );
3355
	},
3356
	nextAll: function( elem ) {
3357
		return dir( elem, "nextSibling" );
3358
	},
3359
	prevAll: function( elem ) {
3360
		return dir( elem, "previousSibling" );
3361
	},
3362
	nextUntil: function( elem, _i, until ) {
3363
		return dir( elem, "nextSibling", until );
3364
	},
3365
	prevUntil: function( elem, _i, until ) {
3366
		return dir( elem, "previousSibling", until );
3367
	},
3368
	siblings: function( elem ) {
3369
		return siblings( ( elem.parentNode || {} ).firstChild, elem );
3370
	},
3371
	children: function( elem ) {
3372
		return siblings( elem.firstChild );
3373
	},
3374
	contents: function( elem ) {
3375
		if ( elem.contentDocument != null &&
3376

3377
			// Support: IE 11+
3378
			// <object> elements with no `data` attribute has an object
3379
			// `contentDocument` with a `null` prototype.
3380
			getProto( elem.contentDocument ) ) {
3381

3382
			return elem.contentDocument;
3383
		}
3384

3385
		// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
3386
		// Treat the template element as a regular one in browsers that
3387
		// don't support it.
3388
		if ( nodeName( elem, "template" ) ) {
3389
			elem = elem.content || elem;
3390
		}
3391

3392
		return jQuery.merge( [], elem.childNodes );
3393
	}
3394
}, function( name, fn ) {
3395
	jQuery.fn[ name ] = function( until, selector ) {
3396
		var matched = jQuery.map( this, fn, until );
3397

3398
		if ( name.slice( -5 ) !== "Until" ) {
3399
			selector = until;
3400
		}
3401

3402
		if ( selector && typeof selector === "string" ) {
3403
			matched = jQuery.filter( selector, matched );
3404
		}
3405

3406
		if ( this.length > 1 ) {
3407

3408
			// Remove duplicates
3409
			if ( !guaranteedUnique[ name ] ) {
3410
				jQuery.uniqueSort( matched );
3411
			}
3412

3413
			// Reverse order for parents* and prev-derivatives
3414
			if ( rparentsprev.test( name ) ) {
3415
				matched.reverse();
3416
			}
3417
		}
3418

3419
		return this.pushStack( matched );
3420
	};
3421
} );
3422
var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
3423

3424

3425

3426
// Convert String-formatted options into Object-formatted ones
3427
function createOptions( options ) {
3428
	var object = {};
3429
	jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
3430
		object[ flag ] = true;
3431
	} );
3432
	return object;
3433
}
3434

3435
/*
3436
 * Create a callback list using the following parameters:
3437
 *
3438
 *	options: an optional list of space-separated options that will change how
3439
 *			the callback list behaves or a more traditional option object
3440
 *
3441
 * By default a callback list will act like an event callback list and can be
3442
 * "fired" multiple times.
3443
 *
3444
 * Possible options:
3445
 *
3446
 *	once:			will ensure the callback list can only be fired once (like a Deferred)
3447
 *
3448
 *	memory:			will keep track of previous values and will call any callback added
3449
 *					after the list has been fired right away with the latest "memorized"
3450
 *					values (like a Deferred)
3451
 *
3452
 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
3453
 *
3454
 *	stopOnFalse:	interrupt callings when a callback returns false
3455
 *
3456
 */
3457
jQuery.Callbacks = function( options ) {
3458

3459
	// Convert options from String-formatted to Object-formatted if needed
3460
	// (we check in cache first)
3461
	options = typeof options === "string" ?
3462
		createOptions( options ) :
3463
		jQuery.extend( {}, options );
3464

3465
	var // Flag to know if list is currently firing
3466
		firing,
3467

3468
		// Last fire value for non-forgettable lists
3469
		memory,
3470

3471
		// Flag to know if list was already fired
3472
		fired,
3473

3474
		// Flag to prevent firing
3475
		locked,
3476

3477
		// Actual callback list
3478
		list = [],
3479

3480
		// Queue of execution data for repeatable lists
3481
		queue = [],
3482

3483
		// Index of currently firing callback (modified by add/remove as needed)
3484
		firingIndex = -1,
3485

3486
		// Fire callbacks
3487
		fire = function() {
3488

3489
			// Enforce single-firing
3490
			locked = locked || options.once;
3491

3492
			// Execute callbacks for all pending executions,
3493
			// respecting firingIndex overrides and runtime changes
3494
			fired = firing = true;
3495
			for ( ; queue.length; firingIndex = -1 ) {
3496
				memory = queue.shift();
3497
				while ( ++firingIndex < list.length ) {
3498

3499
					// Run callback and check for early termination
3500
					if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
3501
						options.stopOnFalse ) {
3502

3503
						// Jump to end and forget the data so .add doesn't re-fire
3504
						firingIndex = list.length;
3505
						memory = false;
3506
					}
3507
				}
3508
			}
3509

3510
			// Forget the data if we're done with it
3511
			if ( !options.memory ) {
3512
				memory = false;
3513
			}
3514

3515
			firing = false;
3516

3517
			// Clean up if we're done firing for good
3518
			if ( locked ) {
3519

3520
				// Keep an empty list if we have data for future add calls
3521
				if ( memory ) {
3522
					list = [];
3523

3524
				// Otherwise, this object is spent
3525
				} else {
3526
					list = "";
3527
				}
3528
			}
3529
		},
3530

3531
		// Actual Callbacks object
3532
		self = {
3533

3534
			// Add a callback or a collection of callbacks to the list
3535
			add: function() {
3536
				if ( list ) {
3537

3538
					// If we have memory from a past run, we should fire after adding
3539
					if ( memory && !firing ) {
3540
						firingIndex = list.length - 1;
3541
						queue.push( memory );
3542
					}
3543

3544
					( function add( args ) {
3545
						jQuery.each( args, function( _, arg ) {
3546
							if ( isFunction( arg ) ) {
3547
								if ( !options.unique || !self.has( arg ) ) {
3548
									list.push( arg );
3549
								}
3550
							} else if ( arg && arg.length && toType( arg ) !== "string" ) {
3551

3552
								// Inspect recursively
3553
								add( arg );
3554
							}
3555
						} );
3556
					} )( arguments );
3557

3558
					if ( memory && !firing ) {
3559
						fire();
3560
					}
3561
				}
3562
				return this;
3563
			},
3564

3565
			// Remove a callback from the list
3566
			remove: function() {
3567
				jQuery.each( arguments, function( _, arg ) {
3568
					var index;
3569
					while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
3570
						list.splice( index, 1 );
3571

3572
						// Handle firing indexes
3573
						if ( index <= firingIndex ) {
3574
							firingIndex--;
3575
						}
3576
					}
3577
				} );
3578
				return this;
3579
			},
3580

3581
			// Check if a given callback is in the list.
3582
			// If no argument is given, return whether or not list has callbacks attached.
3583
			has: function( fn ) {
3584
				return fn ?
3585
					jQuery.inArray( fn, list ) > -1 :
3586
					list.length > 0;
3587
			},
3588

3589
			// Remove all callbacks from the list
3590
			empty: function() {
3591
				if ( list ) {
3592
					list = [];
3593
				}
3594
				return this;
3595
			},
3596

3597
			// Disable .fire and .add
3598
			// Abort any current/pending executions
3599
			// Clear all callbacks and values
3600
			disable: function() {
3601
				locked = queue = [];
3602
				list = memory = "";
3603
				return this;
3604
			},
3605
			disabled: function() {
3606
				return !list;
3607
			},
3608

3609
			// Disable .fire
3610
			// Also disable .add unless we have memory (since it would have no effect)
3611
			// Abort any pending executions
3612
			lock: function() {
3613
				locked = queue = [];
3614
				if ( !memory && !firing ) {
3615
					list = memory = "";
3616
				}
3617
				return this;
3618
			},
3619
			locked: function() {
3620
				return !!locked;
3621
			},
3622

3623
			// Call all callbacks with the given context and arguments
3624
			fireWith: function( context, args ) {
3625
				if ( !locked ) {
3626
					args = args || [];
3627
					args = [ context, args.slice ? args.slice() : args ];
3628
					queue.push( args );
3629
					if ( !firing ) {
3630
						fire();
3631
					}
3632
				}
3633
				return this;
3634
			},
3635

3636
			// Call all the callbacks with the given arguments
3637
			fire: function() {
3638
				self.fireWith( this, arguments );
3639
				return this;
3640
			},
3641

3642
			// To know if the callbacks have already been called at least once
3643
			fired: function() {
3644
				return !!fired;
3645
			}
3646
		};
3647

3648
	return self;
3649
};
3650

3651

3652
function Identity( v ) {
3653
	return v;
3654
}
3655
function Thrower( ex ) {
3656
	throw ex;
3657
}
3658

3659
function adoptValue( value, resolve, reject, noValue ) {
3660
	var method;
3661

3662
	try {
3663

3664
		// Check for promise aspect first to privilege synchronous behavior
3665
		if ( value && isFunction( ( method = value.promise ) ) ) {
3666
			method.call( value ).done( resolve ).fail( reject );
3667

3668
		// Other thenables
3669
		} else if ( value && isFunction( ( method = value.then ) ) ) {
3670
			method.call( value, resolve, reject );
3671

3672
		// Other non-thenables
3673
		} else {
3674

3675
			// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
3676
			// * false: [ value ].slice( 0 ) => resolve( value )
3677
			// * true: [ value ].slice( 1 ) => resolve()
3678
			resolve.apply( undefined, [ value ].slice( noValue ) );
3679
		}
3680

3681
	// For Promises/A+, convert exceptions into rejections
3682
	// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
3683
	// Deferred#then to conditionally suppress rejection.
3684
	} catch ( value ) {
3685

3686
		// Support: Android 4.0 only
3687
		// Strict mode functions invoked without .call/.apply get global-object context
3688
		reject.apply( undefined, [ value ] );
3689
	}
3690
}
3691

3692
jQuery.extend( {
3693

3694
	Deferred: function( func ) {
3695
		var tuples = [
3696

3697
				// action, add listener, callbacks,
3698
				// ... .then handlers, argument index, [final state]
3699
				[ "notify", "progress", jQuery.Callbacks( "memory" ),
3700
					jQuery.Callbacks( "memory" ), 2 ],
3701
				[ "resolve", "done", jQuery.Callbacks( "once memory" ),
3702
					jQuery.Callbacks( "once memory" ), 0, "resolved" ],
3703
				[ "reject", "fail", jQuery.Callbacks( "once memory" ),
3704
					jQuery.Callbacks( "once memory" ), 1, "rejected" ]
3705
			],
3706
			state = "pending",
3707
			promise = {
3708
				state: function() {
3709
					return state;
3710
				},
3711
				always: function() {
3712
					deferred.done( arguments ).fail( arguments );
3713
					return this;
3714
				},
3715
				"catch": function( fn ) {
3716
					return promise.then( null, fn );
3717
				},
3718

3719
				// Keep pipe for back-compat
3720
				pipe: function( /* fnDone, fnFail, fnProgress */ ) {
3721
					var fns = arguments;
3722

3723
					return jQuery.Deferred( function( newDefer ) {
3724
						jQuery.each( tuples, function( _i, tuple ) {
3725

3726
							// Map tuples (progress, done, fail) to arguments (done, fail, progress)
3727
							var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
3728

3729
							// deferred.progress(function() { bind to newDefer or newDefer.notify })
3730
							// deferred.done(function() { bind to newDefer or newDefer.resolve })
3731
							// deferred.fail(function() { bind to newDefer or newDefer.reject })
3732
							deferred[ tuple[ 1 ] ]( function() {
3733
								var returned = fn && fn.apply( this, arguments );
3734
								if ( returned && isFunction( returned.promise ) ) {
3735
									returned.promise()
3736
										.progress( newDefer.notify )
3737
										.done( newDefer.resolve )
3738
										.fail( newDefer.reject );
3739
								} else {
3740
									newDefer[ tuple[ 0 ] + "With" ](
3741
										this,
3742
										fn ? [ returned ] : arguments
3743
									);
3744
								}
3745
							} );
3746
						} );
3747
						fns = null;
3748
					} ).promise();
3749
				},
3750
				then: function( onFulfilled, onRejected, onProgress ) {
3751
					var maxDepth = 0;
3752
					function resolve( depth, deferred, handler, special ) {
3753
						return function() {
3754
							var that = this,
3755
								args = arguments,
3756
								mightThrow = function() {
3757
									var returned, then;
3758

3759
									// Support: Promises/A+ section 2.3.3.3.3
3760
									// https://promisesaplus.com/#point-59
3761
									// Ignore double-resolution attempts
3762
									if ( depth < maxDepth ) {
3763
										return;
3764
									}
3765

3766
									returned = handler.apply( that, args );
3767

3768
									// Support: Promises/A+ section 2.3.1
3769
									// https://promisesaplus.com/#point-48
3770
									if ( returned === deferred.promise() ) {
3771
										throw new TypeError( "Thenable self-resolution" );
3772
									}
3773

3774
									// Support: Promises/A+ sections 2.3.3.1, 3.5
3775
									// https://promisesaplus.com/#point-54
3776
									// https://promisesaplus.com/#point-75
3777
									// Retrieve `then` only once
3778
									then = returned &&
3779

3780
										// Support: Promises/A+ section 2.3.4
3781
										// https://promisesaplus.com/#point-64
3782
										// Only check objects and functions for thenability
3783
										( typeof returned === "object" ||
3784
											typeof returned === "function" ) &&
3785
										returned.then;
3786

3787
									// Handle a returned thenable
3788
									if ( isFunction( then ) ) {
3789

3790
										// Special processors (notify) just wait for resolution
3791
										if ( special ) {
3792
											then.call(
3793
												returned,
3794
												resolve( maxDepth, deferred, Identity, special ),
3795
												resolve( maxDepth, deferred, Thrower, special )
3796
											);
3797

3798
										// Normal processors (resolve) also hook into progress
3799
										} else {
3800

3801
											// ...and disregard older resolution values
3802
											maxDepth++;
3803

3804
											then.call(
3805
												returned,
3806
												resolve( maxDepth, deferred, Identity, special ),
3807
												resolve( maxDepth, deferred, Thrower, special ),
3808
												resolve( maxDepth, deferred, Identity,
3809
													deferred.notifyWith )
3810
											);
3811
										}
3812

3813
									// Handle all other returned values
3814
									} else {
3815

3816
										// Only substitute handlers pass on context
3817
										// and multiple values (non-spec behavior)
3818
										if ( handler !== Identity ) {
3819
											that = undefined;
3820
											args = [ returned ];
3821
										}
3822

3823
										// Process the value(s)
3824
										// Default process is resolve
3825
										( special || deferred.resolveWith )( that, args );
3826
									}
3827
								},
3828

3829
								// Only normal processors (resolve) catch and reject exceptions
3830
								process = special ?
3831
									mightThrow :
3832
									function() {
3833
										try {
3834
											mightThrow();
3835
										} catch ( e ) {
3836

3837
											if ( jQuery.Deferred.exceptionHook ) {
3838
												jQuery.Deferred.exceptionHook( e,
3839
													process.stackTrace );
3840
											}
3841

3842
											// Support: Promises/A+ section 2.3.3.3.4.1
3843
											// https://promisesaplus.com/#point-61
3844
											// Ignore post-resolution exceptions
3845
											if ( depth + 1 >= maxDepth ) {
3846

3847
												// Only substitute handlers pass on context
3848
												// and multiple values (non-spec behavior)
3849
												if ( handler !== Thrower ) {
3850
													that = undefined;
3851
													args = [ e ];
3852
												}
3853

3854
												deferred.rejectWith( that, args );
3855
											}
3856
										}
3857
									};
3858

3859
							// Support: Promises/A+ section 2.3.3.3.1
3860
							// https://promisesaplus.com/#point-57
3861
							// Re-resolve promises immediately to dodge false rejection from
3862
							// subsequent errors
3863
							if ( depth ) {
3864
								process();
3865
							} else {
3866

3867
								// Call an optional hook to record the stack, in case of exception
3868
								// since it's otherwise lost when execution goes async
3869
								if ( jQuery.Deferred.getStackHook ) {
3870
									process.stackTrace = jQuery.Deferred.getStackHook();
3871
								}
3872
								window.setTimeout( process );
3873
							}
3874
						};
3875
					}
3876

3877
					return jQuery.Deferred( function( newDefer ) {
3878

3879
						// progress_handlers.add( ... )
3880
						tuples[ 0 ][ 3 ].add(
3881
							resolve(
3882
								0,
3883
								newDefer,
3884
								isFunction( onProgress ) ?
3885
									onProgress :
3886
									Identity,
3887
								newDefer.notifyWith
3888
							)
3889
						);
3890

3891
						// fulfilled_handlers.add( ... )
3892
						tuples[ 1 ][ 3 ].add(
3893
							resolve(
3894
								0,
3895
								newDefer,
3896
								isFunction( onFulfilled ) ?
3897
									onFulfilled :
3898
									Identity
3899
							)
3900
						);
3901

3902
						// rejected_handlers.add( ... )
3903
						tuples[ 2 ][ 3 ].add(
3904
							resolve(
3905
								0,
3906
								newDefer,
3907
								isFunction( onRejected ) ?
3908
									onRejected :
3909
									Thrower
3910
							)
3911
						);
3912
					} ).promise();
3913
				},
3914

3915
				// Get a promise for this deferred
3916
				// If obj is provided, the promise aspect is added to the object
3917
				promise: function( obj ) {
3918
					return obj != null ? jQuery.extend( obj, promise ) : promise;
3919
				}
3920
			},
3921
			deferred = {};
3922

3923
		// Add list-specific methods
3924
		jQuery.each( tuples, function( i, tuple ) {
3925
			var list = tuple[ 2 ],
3926
				stateString = tuple[ 5 ];
3927

3928
			// promise.progress = list.add
3929
			// promise.done = list.add
3930
			// promise.fail = list.add
3931
			promise[ tuple[ 1 ] ] = list.add;
3932

3933
			// Handle state
3934
			if ( stateString ) {
3935
				list.add(
3936
					function() {
3937

3938
						// state = "resolved" (i.e., fulfilled)
3939
						// state = "rejected"
3940
						state = stateString;
3941
					},
3942

3943
					// rejected_callbacks.disable
3944
					// fulfilled_callbacks.disable
3945
					tuples[ 3 - i ][ 2 ].disable,
3946

3947
					// rejected_handlers.disable
3948
					// fulfilled_handlers.disable
3949
					tuples[ 3 - i ][ 3 ].disable,
3950

3951
					// progress_callbacks.lock
3952
					tuples[ 0 ][ 2 ].lock,
3953

3954
					// progress_handlers.lock
3955
					tuples[ 0 ][ 3 ].lock
3956
				);
3957
			}
3958

3959
			// progress_handlers.fire
3960
			// fulfilled_handlers.fire
3961
			// rejected_handlers.fire
3962
			list.add( tuple[ 3 ].fire );
3963

3964
			// deferred.notify = function() { deferred.notifyWith(...) }
3965
			// deferred.resolve = function() { deferred.resolveWith(...) }
3966
			// deferred.reject = function() { deferred.rejectWith(...) }
3967
			deferred[ tuple[ 0 ] ] = function() {
3968
				deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
3969
				return this;
3970
			};
3971

3972
			// deferred.notifyWith = list.fireWith
3973
			// deferred.resolveWith = list.fireWith
3974
			// deferred.rejectWith = list.fireWith
3975
			deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
3976
		} );
3977

3978
		// Make the deferred a promise
3979
		promise.promise( deferred );
3980

3981
		// Call given func if any
3982
		if ( func ) {
3983
			func.call( deferred, deferred );
3984
		}
3985

3986
		// All done!
3987
		return deferred;
3988
	},
3989

3990
	// Deferred helper
3991
	when: function( singleValue ) {
3992
		var
3993

3994
			// count of uncompleted subordinates
3995
			remaining = arguments.length,
3996

3997
			// count of unprocessed arguments
3998
			i = remaining,
3999

4000
			// subordinate fulfillment data
4001
			resolveContexts = Array( i ),
4002
			resolveValues = slice.call( arguments ),
4003

4004
			// the primary Deferred
4005
			primary = jQuery.Deferred(),
4006

4007
			// subordinate callback factory
4008
			updateFunc = function( i ) {
4009
				return function( value ) {
4010
					resolveContexts[ i ] = this;
4011
					resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
4012
					if ( !( --remaining ) ) {
4013
						primary.resolveWith( resolveContexts, resolveValues );
4014
					}
4015
				};
4016
			};
4017

4018
		// Single- and empty arguments are adopted like Promise.resolve
4019
		if ( remaining <= 1 ) {
4020
			adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,
4021
				!remaining );
4022

4023
			// Use .then() to unwrap secondary thenables (cf. gh-3000)
4024
			if ( primary.state() === "pending" ||
4025
				isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
4026

4027
				return primary.then();
4028
			}
4029
		}
4030

4031
		// Multiple arguments are aggregated like Promise.all array elements
4032
		while ( i-- ) {
4033
			adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );
4034
		}
4035

4036
		return primary.promise();
4037
	}
4038
} );
4039

4040

4041
// These usually indicate a programmer mistake during development,
4042
// warn about them ASAP rather than swallowing them by default.
4043
var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
4044

4045
jQuery.Deferred.exceptionHook = function( error, stack ) {
4046

4047
	// Support: IE 8 - 9 only
4048
	// Console exists when dev tools are open, which can happen at any time
4049
	if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
4050
		window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
4051
	}
4052
};
4053

4054

4055

4056

4057
jQuery.readyException = function( error ) {
4058
	window.setTimeout( function() {
4059
		throw error;
4060
	} );
4061
};
4062

4063

4064

4065

4066
// The deferred used on DOM ready
4067
var readyList = jQuery.Deferred();
4068

4069
jQuery.fn.ready = function( fn ) {
4070

4071
	readyList
4072
		.then( fn )
4073

4074
		// Wrap jQuery.readyException in a function so that the lookup
4075
		// happens at the time of error handling instead of callback
4076
		// registration.
4077
		.catch( function( error ) {
4078
			jQuery.readyException( error );
4079
		} );
4080

4081
	return this;
4082
};
4083

4084
jQuery.extend( {
4085

4086
	// Is the DOM ready to be used? Set to true once it occurs.
4087
	isReady: false,
4088

4089
	// A counter to track how many items to wait for before
4090
	// the ready event fires. See #6781
4091
	readyWait: 1,
4092

4093
	// Handle when the DOM is ready
4094
	ready: function( wait ) {
4095

4096
		// Abort if there are pending holds or we're already ready
4097
		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
4098
			return;
4099
		}
4100

4101
		// Remember that the DOM is ready
4102
		jQuery.isReady = true;
4103

4104
		// If a normal DOM Ready event fired, decrement, and wait if need be
4105
		if ( wait !== true && --jQuery.readyWait > 0 ) {
4106
			return;
4107
		}
4108

4109
		// If there are functions bound, to execute
4110
		readyList.resolveWith( document, [ jQuery ] );
4111
	}
4112
} );
4113

4114
jQuery.ready.then = readyList.then;
4115

4116
// The ready event handler and self cleanup method
4117
function completed() {
4118
	document.removeEventListener( "DOMContentLoaded", completed );
4119
	window.removeEventListener( "load", completed );
4120
	jQuery.ready();
4121
}
4122

4123
// Catch cases where $(document).ready() is called
4124
// after the browser event has already occurred.
4125
// Support: IE <=9 - 10 only
4126
// Older IE sometimes signals "interactive" too soon
4127
if ( document.readyState === "complete" ||
4128
	( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
4129

4130
	// Handle it asynchronously to allow scripts the opportunity to delay ready
4131
	window.setTimeout( jQuery.ready );
4132

4133
} else {
4134

4135
	// Use the handy event callback
4136
	document.addEventListener( "DOMContentLoaded", completed );
4137

4138
	// A fallback to window.onload, that will always work
4139
	window.addEventListener( "load", completed );
4140
}
4141

4142

4143

4144

4145
// Multifunctional method to get and set values of a collection
4146
// The value/s can optionally be executed if it's a function
4147
var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
4148
	var i = 0,
4149
		len = elems.length,
4150
		bulk = key == null;
4151

4152
	// Sets many values
4153
	if ( toType( key ) === "object" ) {
4154
		chainable = true;
4155
		for ( i in key ) {
4156
			access( elems, fn, i, key[ i ], true, emptyGet, raw );
4157
		}
4158

4159
	// Sets one value
4160
	} else if ( value !== undefined ) {
4161
		chainable = true;
4162

4163
		if ( !isFunction( value ) ) {
4164
			raw = true;
4165
		}
4166

4167
		if ( bulk ) {
4168

4169
			// Bulk operations run against the entire set
4170
			if ( raw ) {
4171
				fn.call( elems, value );
4172
				fn = null;
4173

4174
			// ...except when executing function values
4175
			} else {
4176
				bulk = fn;
4177
				fn = function( elem, _key, value ) {
4178
					return bulk.call( jQuery( elem ), value );
4179
				};
4180
			}
4181
		}
4182

4183
		if ( fn ) {
4184
			for ( ; i < len; i++ ) {
4185
				fn(
4186
					elems[ i ], key, raw ?
4187
						value :
4188
						value.call( elems[ i ], i, fn( elems[ i ], key ) )
4189
				);
4190
			}
4191
		}
4192
	}
4193

4194
	if ( chainable ) {
4195
		return elems;
4196
	}
4197

4198
	// Gets
4199
	if ( bulk ) {
4200
		return fn.call( elems );
4201
	}
4202

4203
	return len ? fn( elems[ 0 ], key ) : emptyGet;
4204
};
4205

4206

4207
// Matches dashed string for camelizing
4208
var rmsPrefix = /^-ms-/,
4209
	rdashAlpha = /-([a-z])/g;
4210

4211
// Used by camelCase as callback to replace()
4212
function fcamelCase( _all, letter ) {
4213
	return letter.toUpperCase();
4214
}
4215

4216
// Convert dashed to camelCase; used by the css and data modules
4217
// Support: IE <=9 - 11, Edge 12 - 15
4218
// Microsoft forgot to hump their vendor prefix (#9572)
4219
function camelCase( string ) {
4220
	return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
4221
}
4222
var acceptData = function( owner ) {
4223

4224
	// Accepts only:
4225
	//  - Node
4226
	//    - Node.ELEMENT_NODE
4227
	//    - Node.DOCUMENT_NODE
4228
	//  - Object
4229
	//    - Any
4230
	return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
4231
};
4232

4233

4234

4235

4236
function Data() {
4237
	this.expando = jQuery.expando + Data.uid++;
4238
}
4239

4240
Data.uid = 1;
4241

4242
Data.prototype = {
4243

4244
	cache: function( owner ) {
4245

4246
		// Check if the owner object already has a cache
4247
		var value = owner[ this.expando ];
4248

4249
		// If not, create one
4250
		if ( !value ) {
4251
			value = {};
4252

4253
			// We can accept data for non-element nodes in modern browsers,
4254
			// but we should not, see #8335.
4255
			// Always return an empty object.
4256
			if ( acceptData( owner ) ) {
4257

4258
				// If it is a node unlikely to be stringify-ed or looped over
4259
				// use plain assignment
4260
				if ( owner.nodeType ) {
4261
					owner[ this.expando ] = value;
4262

4263
				// Otherwise secure it in a non-enumerable property
4264
				// configurable must be true to allow the property to be
4265
				// deleted when data is removed
4266
				} else {
4267
					Object.defineProperty( owner, this.expando, {
4268
						value: value,
4269
						configurable: true
4270
					} );
4271
				}
4272
			}
4273
		}
4274

4275
		return value;
4276
	},
4277
	set: function( owner, data, value ) {
4278
		var prop,
4279
			cache = this.cache( owner );
4280

4281
		// Handle: [ owner, key, value ] args
4282
		// Always use camelCase key (gh-2257)
4283
		if ( typeof data === "string" ) {
4284
			cache[ camelCase( data ) ] = value;
4285

4286
		// Handle: [ owner, { properties } ] args
4287
		} else {
4288

4289
			// Copy the properties one-by-one to the cache object
4290
			for ( prop in data ) {
4291
				cache[ camelCase( prop ) ] = data[ prop ];
4292
			}
4293
		}
4294
		return cache;
4295
	},
4296
	get: function( owner, key ) {
4297
		return key === undefined ?
4298
			this.cache( owner ) :
4299

4300
			// Always use camelCase key (gh-2257)
4301
			owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];
4302
	},
4303
	access: function( owner, key, value ) {
4304

4305
		// In cases where either:
4306
		//
4307
		//   1. No key was specified
4308
		//   2. A string key was specified, but no value provided
4309
		//
4310
		// Take the "read" path and allow the get method to determine
4311
		// which value to return, respectively either:
4312
		//
4313
		//   1. The entire cache object
4314
		//   2. The data stored at the key
4315
		//
4316
		if ( key === undefined ||
4317
				( ( key && typeof key === "string" ) && value === undefined ) ) {
4318

4319
			return this.get( owner, key );
4320
		}
4321

4322
		// When the key is not a string, or both a key and value
4323
		// are specified, set or extend (existing objects) with either:
4324
		//
4325
		//   1. An object of properties
4326
		//   2. A key and value
4327
		//
4328
		this.set( owner, key, value );
4329

4330
		// Since the "set" path can have two possible entry points
4331
		// return the expected data based on which path was taken[*]
4332
		return value !== undefined ? value : key;
4333
	},
4334
	remove: function( owner, key ) {
4335
		var i,
4336
			cache = owner[ this.expando ];
4337

4338
		if ( cache === undefined ) {
4339
			return;
4340
		}
4341

4342
		if ( key !== undefined ) {
4343

4344
			// Support array or space separated string of keys
4345
			if ( Array.isArray( key ) ) {
4346

4347
				// If key is an array of keys...
4348
				// We always set camelCase keys, so remove that.
4349
				key = key.map( camelCase );
4350
			} else {
4351
				key = camelCase( key );
4352

4353
				// If a key with the spaces exists, use it.
4354
				// Otherwise, create an array by matching non-whitespace
4355
				key = key in cache ?
4356
					[ key ] :
4357
					( key.match( rnothtmlwhite ) || [] );
4358
			}
4359

4360
			i = key.length;
4361

4362
			while ( i-- ) {
4363
				delete cache[ key[ i ] ];
4364
			}
4365
		}
4366

4367
		// Remove the expando if there's no more data
4368
		if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
4369

4370
			// Support: Chrome <=35 - 45
4371
			// Webkit & Blink performance suffers when deleting properties
4372
			// from DOM nodes, so set to undefined instead
4373
			// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
4374
			if ( owner.nodeType ) {
4375
				owner[ this.expando ] = undefined;
4376
			} else {
4377
				delete owner[ this.expando ];
4378
			}
4379
		}
4380
	},
4381
	hasData: function( owner ) {
4382
		var cache = owner[ this.expando ];
4383
		return cache !== undefined && !jQuery.isEmptyObject( cache );
4384
	}
4385
};
4386
var dataPriv = new Data();
4387

4388
var dataUser = new Data();
4389

4390

4391

4392
//	Implementation Summary
4393
//
4394
//	1. Enforce API surface and semantic compatibility with 1.9.x branch
4395
//	2. Improve the module's maintainability by reducing the storage
4396
//		paths to a single mechanism.
4397
//	3. Use the same single mechanism to support "private" and "user" data.
4398
//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
4399
//	5. Avoid exposing implementation details on user objects (eg. expando properties)
4400
//	6. Provide a clear path for implementation upgrade to WeakMap in 2014
4401

4402
var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
4403
	rmultiDash = /[A-Z]/g;
4404

4405
function getData( data ) {
4406
	if ( data === "true" ) {
4407
		return true;
4408
	}
4409

4410
	if ( data === "false" ) {
4411
		return false;
4412
	}
4413

4414
	if ( data === "null" ) {
4415
		return null;
4416
	}
4417

4418
	// Only convert to a number if it doesn't change the string
4419
	if ( data === +data + "" ) {
4420
		return +data;
4421
	}
4422

4423
	if ( rbrace.test( data ) ) {
4424
		return JSON.parse( data );
4425
	}
4426

4427
	return data;
4428
}
4429

4430
function dataAttr( elem, key, data ) {
4431
	var name;
4432

4433
	// If nothing was found internally, try to fetch any
4434
	// data from the HTML5 data-* attribute
4435
	if ( data === undefined && elem.nodeType === 1 ) {
4436
		name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
4437
		data = elem.getAttribute( name );
4438

4439
		if ( typeof data === "string" ) {
4440
			try {
4441
				data = getData( data );
4442
			} catch ( e ) {}
4443

4444
			// Make sure we set the data so it isn't changed later
4445
			dataUser.set( elem, key, data );
4446
		} else {
4447
			data = undefined;
4448
		}
4449
	}
4450
	return data;
4451
}
4452

4453
jQuery.extend( {
4454
	hasData: function( elem ) {
4455
		return dataUser.hasData( elem ) || dataPriv.hasData( elem );
4456
	},
4457

4458
	data: function( elem, name, data ) {
4459
		return dataUser.access( elem, name, data );
4460
	},
4461

4462
	removeData: function( elem, name ) {
4463
		dataUser.remove( elem, name );
4464
	},
4465

4466
	// TODO: Now that all calls to _data and _removeData have been replaced
4467
	// with direct calls to dataPriv methods, these can be deprecated.
4468
	_data: function( elem, name, data ) {
4469
		return dataPriv.access( elem, name, data );
4470
	},
4471

4472
	_removeData: function( elem, name ) {
4473
		dataPriv.remove( elem, name );
4474
	}
4475
} );
4476

4477
jQuery.fn.extend( {
4478
	data: function( key, value ) {
4479
		var i, name, data,
4480
			elem = this[ 0 ],
4481
			attrs = elem && elem.attributes;
4482

4483
		// Gets all values
4484
		if ( key === undefined ) {
4485
			if ( this.length ) {
4486
				data = dataUser.get( elem );
4487

4488
				if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
4489
					i = attrs.length;
4490
					while ( i-- ) {
4491

4492
						// Support: IE 11 only
4493
						// The attrs elements can be null (#14894)
4494
						if ( attrs[ i ] ) {
4495
							name = attrs[ i ].name;
4496
							if ( name.indexOf( "data-" ) === 0 ) {
4497
								name = camelCase( name.slice( 5 ) );
4498
								dataAttr( elem, name, data[ name ] );
4499
							}
4500
						}
4501
					}
4502
					dataPriv.set( elem, "hasDataAttrs", true );
4503
				}
4504
			}
4505

4506
			return data;
4507
		}
4508

4509
		// Sets multiple values
4510
		if ( typeof key === "object" ) {
4511
			return this.each( function() {
4512
				dataUser.set( this, key );
4513
			} );
4514
		}
4515

4516
		return access( this, function( value ) {
4517
			var data;
4518

4519
			// The calling jQuery object (element matches) is not empty
4520
			// (and therefore has an element appears at this[ 0 ]) and the
4521
			// `value` parameter was not undefined. An empty jQuery object
4522
			// will result in `undefined` for elem = this[ 0 ] which will
4523
			// throw an exception if an attempt to read a data cache is made.
4524
			if ( elem && value === undefined ) {
4525

4526
				// Attempt to get data from the cache
4527
				// The key will always be camelCased in Data
4528
				data = dataUser.get( elem, key );
4529
				if ( data !== undefined ) {
4530
					return data;
4531
				}
4532

4533
				// Attempt to "discover" the data in
4534
				// HTML5 custom data-* attrs
4535
				data = dataAttr( elem, key );
4536
				if ( data !== undefined ) {
4537
					return data;
4538
				}
4539

4540
				// We tried really hard, but the data doesn't exist.
4541
				return;
4542
			}
4543

4544
			// Set the data...
4545
			this.each( function() {
4546

4547
				// We always store the camelCased key
4548
				dataUser.set( this, key, value );
4549
			} );
4550
		}, null, value, arguments.length > 1, null, true );
4551
	},
4552

4553
	removeData: function( key ) {
4554
		return this.each( function() {
4555
			dataUser.remove( this, key );
4556
		} );
4557
	}
4558
} );
4559

4560

4561
jQuery.extend( {
4562
	queue: function( elem, type, data ) {
4563
		var queue;
4564

4565
		if ( elem ) {
4566
			type = ( type || "fx" ) + "queue";
4567
			queue = dataPriv.get( elem, type );
4568

4569
			// Speed up dequeue by getting out quickly if this is just a lookup
4570
			if ( data ) {
4571
				if ( !queue || Array.isArray( data ) ) {
4572
					queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
4573
				} else {
4574
					queue.push( data );
4575
				}
4576
			}
4577
			return queue || [];
4578
		}
4579
	},
4580

4581
	dequeue: function( elem, type ) {
4582
		type = type || "fx";
4583

4584
		var queue = jQuery.queue( elem, type ),
4585
			startLength = queue.length,
4586
			fn = queue.shift(),
4587
			hooks = jQuery._queueHooks( elem, type ),
4588
			next = function() {
4589
				jQuery.dequeue( elem, type );
4590
			};
4591

4592
		// If the fx queue is dequeued, always remove the progress sentinel
4593
		if ( fn === "inprogress" ) {
4594
			fn = queue.shift();
4595
			startLength--;
4596
		}
4597

4598
		if ( fn ) {
4599

4600
			// Add a progress sentinel to prevent the fx queue from being
4601
			// automatically dequeued
4602
			if ( type === "fx" ) {
4603
				queue.unshift( "inprogress" );
4604
			}
4605

4606
			// Clear up the last queue stop function
4607
			delete hooks.stop;
4608
			fn.call( elem, next, hooks );
4609
		}
4610

4611
		if ( !startLength && hooks ) {
4612
			hooks.empty.fire();
4613
		}
4614
	},
4615

4616
	// Not public - generate a queueHooks object, or return the current one
4617
	_queueHooks: function( elem, type ) {
4618
		var key = type + "queueHooks";
4619
		return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
4620
			empty: jQuery.Callbacks( "once memory" ).add( function() {
4621
				dataPriv.remove( elem, [ type + "queue", key ] );
4622
			} )
4623
		} );
4624
	}
4625
} );
4626

4627
jQuery.fn.extend( {
4628
	queue: function( type, data ) {
4629
		var setter = 2;
4630

4631
		if ( typeof type !== "string" ) {
4632
			data = type;
4633
			type = "fx";
4634
			setter--;
4635
		}
4636

4637
		if ( arguments.length < setter ) {
4638
			return jQuery.queue( this[ 0 ], type );
4639
		}
4640

4641
		return data === undefined ?
4642
			this :
4643
			this.each( function() {
4644
				var queue = jQuery.queue( this, type, data );
4645

4646
				// Ensure a hooks for this queue
4647
				jQuery._queueHooks( this, type );
4648

4649
				if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
4650
					jQuery.dequeue( this, type );
4651
				}
4652
			} );
4653
	},
4654
	dequeue: function( type ) {
4655
		return this.each( function() {
4656
			jQuery.dequeue( this, type );
4657
		} );
4658
	},
4659
	clearQueue: function( type ) {
4660
		return this.queue( type || "fx", [] );
4661
	},
4662

4663
	// Get a promise resolved when queues of a certain type
4664
	// are emptied (fx is the type by default)
4665
	promise: function( type, obj ) {
4666
		var tmp,
4667
			count = 1,
4668
			defer = jQuery.Deferred(),
4669
			elements = this,
4670
			i = this.length,
4671
			resolve = function() {
4672
				if ( !( --count ) ) {
4673
					defer.resolveWith( elements, [ elements ] );
4674
				}
4675
			};
4676

4677
		if ( typeof type !== "string" ) {
4678
			obj = type;
4679
			type = undefined;
4680
		}
4681
		type = type || "fx";
4682

4683
		while ( i-- ) {
4684
			tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
4685
			if ( tmp && tmp.empty ) {
4686
				count++;
4687
				tmp.empty.add( resolve );
4688
			}
4689
		}
4690
		resolve();
4691
		return defer.promise( obj );
4692
	}
4693
} );
4694
var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
4695

4696
var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
4697

4698

4699
var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
4700

4701
var documentElement = document.documentElement;
4702

4703

4704

4705
	var isAttached = function( elem ) {
4706
			return jQuery.contains( elem.ownerDocument, elem );
4707
		},
4708
		composed = { composed: true };
4709

4710
	// Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only
4711
	// Check attachment across shadow DOM boundaries when possible (gh-3504)
4712
	// Support: iOS 10.0-10.2 only
4713
	// Early iOS 10 versions support `attachShadow` but not `getRootNode`,
4714
	// leading to errors. We need to check for `getRootNode`.
4715
	if ( documentElement.getRootNode ) {
4716
		isAttached = function( elem ) {
4717
			return jQuery.contains( elem.ownerDocument, elem ) ||
4718
				elem.getRootNode( composed ) === elem.ownerDocument;
4719
		};
4720
	}
4721
var isHiddenWithinTree = function( elem, el ) {
4722

4723
		// isHiddenWithinTree might be called from jQuery#filter function;
4724
		// in that case, element will be second argument
4725
		elem = el || elem;
4726

4727
		// Inline style trumps all
4728
		return elem.style.display === "none" ||
4729
			elem.style.display === "" &&
4730

4731
			// Otherwise, check computed style
4732
			// Support: Firefox <=43 - 45
4733
			// Disconnected elements can have computed display: none, so first confirm that elem is
4734
			// in the document.
4735
			isAttached( elem ) &&
4736

4737
			jQuery.css( elem, "display" ) === "none";
4738
	};
4739

4740

4741

4742
function adjustCSS( elem, prop, valueParts, tween ) {
4743
	var adjusted, scale,
4744
		maxIterations = 20,
4745
		currentValue = tween ?
4746
			function() {
4747
				return tween.cur();
4748
			} :
4749
			function() {
4750
				return jQuery.css( elem, prop, "" );
4751
			},
4752
		initial = currentValue(),
4753
		unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
4754

4755
		// Starting value computation is required for potential unit mismatches
4756
		initialInUnit = elem.nodeType &&
4757
			( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
4758
			rcssNum.exec( jQuery.css( elem, prop ) );
4759

4760
	if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
4761

4762
		// Support: Firefox <=54
4763
		// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
4764
		initial = initial / 2;
4765

4766
		// Trust units reported by jQuery.css
4767
		unit = unit || initialInUnit[ 3 ];
4768

4769
		// Iteratively approximate from a nonzero starting point
4770
		initialInUnit = +initial || 1;
4771

4772
		while ( maxIterations-- ) {
4773

4774
			// Evaluate and update our best guess (doubling guesses that zero out).
4775
			// Finish if the scale equals or crosses 1 (making the old*new product non-positive).
4776
			jQuery.style( elem, prop, initialInUnit + unit );
4777
			if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {
4778
				maxIterations = 0;
4779
			}
4780
			initialInUnit = initialInUnit / scale;
4781

4782
		}
4783

4784
		initialInUnit = initialInUnit * 2;
4785
		jQuery.style( elem, prop, initialInUnit + unit );
4786

4787
		// Make sure we update the tween properties later on
4788
		valueParts = valueParts || [];
4789
	}
4790

4791
	if ( valueParts ) {
4792
		initialInUnit = +initialInUnit || +initial || 0;
4793

4794
		// Apply relative offset (+=/-=) if specified
4795
		adjusted = valueParts[ 1 ] ?
4796
			initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
4797
			+valueParts[ 2 ];
4798
		if ( tween ) {
4799
			tween.unit = unit;
4800
			tween.start = initialInUnit;
4801
			tween.end = adjusted;
4802
		}
4803
	}
4804
	return adjusted;
4805
}
4806

4807

4808
var defaultDisplayMap = {};
4809

4810
function getDefaultDisplay( elem ) {
4811
	var temp,
4812
		doc = elem.ownerDocument,
4813
		nodeName = elem.nodeName,
4814
		display = defaultDisplayMap[ nodeName ];
4815

4816
	if ( display ) {
4817
		return display;
4818
	}
4819

4820
	temp = doc.body.appendChild( doc.createElement( nodeName ) );
4821
	display = jQuery.css( temp, "display" );
4822

4823
	temp.parentNode.removeChild( temp );
4824

4825
	if ( display === "none" ) {
4826
		display = "block";
4827
	}
4828
	defaultDisplayMap[ nodeName ] = display;
4829

4830
	return display;
4831
}
4832

4833
function showHide( elements, show ) {
4834
	var display, elem,
4835
		values = [],
4836
		index = 0,
4837
		length = elements.length;
4838

4839
	// Determine new display value for elements that need to change
4840
	for ( ; index < length; index++ ) {
4841
		elem = elements[ index ];
4842
		if ( !elem.style ) {
4843
			continue;
4844
		}
4845

4846
		display = elem.style.display;
4847
		if ( show ) {
4848

4849
			// Since we force visibility upon cascade-hidden elements, an immediate (and slow)
4850
			// check is required in this first loop unless we have a nonempty display value (either
4851
			// inline or about-to-be-restored)
4852
			if ( display === "none" ) {
4853
				values[ index ] = dataPriv.get( elem, "display" ) || null;
4854
				if ( !values[ index ] ) {
4855
					elem.style.display = "";
4856
				}
4857
			}
4858
			if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
4859
				values[ index ] = getDefaultDisplay( elem );
4860
			}
4861
		} else {
4862
			if ( display !== "none" ) {
4863
				values[ index ] = "none";
4864

4865
				// Remember what we're overwriting
4866
				dataPriv.set( elem, "display", display );
4867
			}
4868
		}
4869
	}
4870

4871
	// Set the display of the elements in a second loop to avoid constant reflow
4872
	for ( index = 0; index < length; index++ ) {
4873
		if ( values[ index ] != null ) {
4874
			elements[ index ].style.display = values[ index ];
4875
		}
4876
	}
4877

4878
	return elements;
4879
}
4880

4881
jQuery.fn.extend( {
4882
	show: function() {
4883
		return showHide( this, true );
4884
	},
4885
	hide: function() {
4886
		return showHide( this );
4887
	},
4888
	toggle: function( state ) {
4889
		if ( typeof state === "boolean" ) {
4890
			return state ? this.show() : this.hide();
4891
		}
4892

4893
		return this.each( function() {
4894
			if ( isHiddenWithinTree( this ) ) {
4895
				jQuery( this ).show();
4896
			} else {
4897
				jQuery( this ).hide();
4898
			}
4899
		} );
4900
	}
4901
} );
4902
var rcheckableType = ( /^(?:checkbox|radio)$/i );
4903

4904
var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i );
4905

4906
var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i );
4907

4908

4909

4910
( function() {
4911
	var fragment = document.createDocumentFragment(),
4912
		div = fragment.appendChild( document.createElement( "div" ) ),
4913
		input = document.createElement( "input" );
4914

4915
	// Support: Android 4.0 - 4.3 only
4916
	// Check state lost if the name is set (#11217)
4917
	// Support: Windows Web Apps (WWA)
4918
	// `name` and `type` must use .setAttribute for WWA (#14901)
4919
	input.setAttribute( "type", "radio" );
4920
	input.setAttribute( "checked", "checked" );
4921
	input.setAttribute( "name", "t" );
4922

4923
	div.appendChild( input );
4924

4925
	// Support: Android <=4.1 only
4926
	// Older WebKit doesn't clone checked state correctly in fragments
4927
	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
4928

4929
	// Support: IE <=11 only
4930
	// Make sure textarea (and checkbox) defaultValue is properly cloned
4931
	div.innerHTML = "<textarea>x</textarea>";
4932
	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
4933

4934
	// Support: IE <=9 only
4935
	// IE <=9 replaces <option> tags with their contents when inserted outside of
4936
	// the select element.
4937
	div.innerHTML = "<option></option>";
4938
	support.option = !!div.lastChild;
4939
} )();
4940

4941

4942
// We have to close these tags to support XHTML (#13200)
4943
var wrapMap = {
4944

4945
	// XHTML parsers do not magically insert elements in the
4946
	// same way that tag soup parsers do. So we cannot shorten
4947
	// this by omitting <tbody> or other required elements.
4948
	thead: [ 1, "<table>", "</table>" ],
4949
	col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
4950
	tr: [ 2, "<table><tbody>", "</tbody></table>" ],
4951
	td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
4952

4953
	_default: [ 0, "", "" ]
4954
};
4955

4956
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
4957
wrapMap.th = wrapMap.td;
4958

4959
// Support: IE <=9 only
4960
if ( !support.option ) {
4961
	wrapMap.optgroup = wrapMap.option = [ 1, "<select multiple='multiple'>", "</select>" ];
4962
}
4963

4964

4965
function getAll( context, tag ) {
4966

4967
	// Support: IE <=9 - 11 only
4968
	// Use typeof to avoid zero-argument method invocation on host objects (#15151)
4969
	var ret;
4970

4971
	if ( typeof context.getElementsByTagName !== "undefined" ) {
4972
		ret = context.getElementsByTagName( tag || "*" );
4973

4974
	} else if ( typeof context.querySelectorAll !== "undefined" ) {
4975
		ret = context.querySelectorAll( tag || "*" );
4976

4977
	} else {
4978
		ret = [];
4979
	}
4980

4981
	if ( tag === undefined || tag && nodeName( context, tag ) ) {
4982
		return jQuery.merge( [ context ], ret );
4983
	}
4984

4985
	return ret;
4986
}
4987

4988

4989
// Mark scripts as having already been evaluated
4990
function setGlobalEval( elems, refElements ) {
4991
	var i = 0,
4992
		l = elems.length;
4993

4994
	for ( ; i < l; i++ ) {
4995
		dataPriv.set(
4996
			elems[ i ],
4997
			"globalEval",
4998
			!refElements || dataPriv.get( refElements[ i ], "globalEval" )
4999
		);
5000
	}
5001
}
5002

5003

5004
var rhtml = /<|&#?\w+;/;
5005

5006
function buildFragment( elems, context, scripts, selection, ignored ) {
5007
	var elem, tmp, tag, wrap, attached, j,
5008
		fragment = context.createDocumentFragment(),
5009
		nodes = [],
5010
		i = 0,
5011
		l = elems.length;
5012

5013
	for ( ; i < l; i++ ) {
5014
		elem = elems[ i ];
5015

5016
		if ( elem || elem === 0 ) {
5017

5018
			// Add nodes directly
5019
			if ( toType( elem ) === "object" ) {
5020

5021
				// Support: Android <=4.0 only, PhantomJS 1 only
5022
				// push.apply(_, arraylike) throws on ancient WebKit
5023
				jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
5024

5025
			// Convert non-html into a text node
5026
			} else if ( !rhtml.test( elem ) ) {
5027
				nodes.push( context.createTextNode( elem ) );
5028

5029
			// Convert html into DOM nodes
5030
			} else {
5031
				tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
5032

5033
				// Deserialize a standard representation
5034
				tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
5035
				wrap = wrapMap[ tag ] || wrapMap._default;
5036
				tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
5037

5038
				// Descend through wrappers to the right content
5039
				j = wrap[ 0 ];
5040
				while ( j-- ) {
5041
					tmp = tmp.lastChild;
5042
				}
5043

5044
				// Support: Android <=4.0 only, PhantomJS 1 only
5045
				// push.apply(_, arraylike) throws on ancient WebKit
5046
				jQuery.merge( nodes, tmp.childNodes );
5047

5048
				// Remember the top-level container
5049
				tmp = fragment.firstChild;
5050

5051
				// Ensure the created nodes are orphaned (#12392)
5052
				tmp.textContent = "";
5053
			}
5054
		}
5055
	}
5056

5057
	// Remove wrapper from fragment
5058
	fragment.textContent = "";
5059

5060
	i = 0;
5061
	while ( ( elem = nodes[ i++ ] ) ) {
5062

5063
		// Skip elements already in the context collection (trac-4087)
5064
		if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
5065
			if ( ignored ) {
5066
				ignored.push( elem );
5067
			}
5068
			continue;
5069
		}
5070

5071
		attached = isAttached( elem );
5072

5073
		// Append to fragment
5074
		tmp = getAll( fragment.appendChild( elem ), "script" );
5075

5076
		// Preserve script evaluation history
5077
		if ( attached ) {
5078
			setGlobalEval( tmp );
5079
		}
5080

5081
		// Capture executables
5082
		if ( scripts ) {
5083
			j = 0;
5084
			while ( ( elem = tmp[ j++ ] ) ) {
5085
				if ( rscriptType.test( elem.type || "" ) ) {
5086
					scripts.push( elem );
5087
				}
5088
			}
5089
		}
5090
	}
5091

5092
	return fragment;
5093
}
5094

5095

5096
var rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
5097

5098
function returnTrue() {
5099
	return true;
5100
}
5101

5102
function returnFalse() {
5103
	return false;
5104
}
5105

5106
// Support: IE <=9 - 11+
5107
// focus() and blur() are asynchronous, except when they are no-op.
5108
// So expect focus to be synchronous when the element is already active,
5109
// and blur to be synchronous when the element is not already active.
5110
// (focus and blur are always synchronous in other supported browsers,
5111
// this just defines when we can count on it).
5112
function expectSync( elem, type ) {
5113
	return ( elem === safeActiveElement() ) === ( type === "focus" );
5114
}
5115

5116
// Support: IE <=9 only
5117
// Accessing document.activeElement can throw unexpectedly
5118
// https://bugs.jquery.com/ticket/13393
5119
function safeActiveElement() {
5120
	try {
5121
		return document.activeElement;
5122
	} catch ( err ) { }
5123
}
5124

5125
function on( elem, types, selector, data, fn, one ) {
5126
	var origFn, type;
5127

5128
	// Types can be a map of types/handlers
5129
	if ( typeof types === "object" ) {
5130

5131
		// ( types-Object, selector, data )
5132
		if ( typeof selector !== "string" ) {
5133

5134
			// ( types-Object, data )
5135
			data = data || selector;
5136
			selector = undefined;
5137
		}
5138
		for ( type in types ) {
5139
			on( elem, type, selector, data, types[ type ], one );
5140
		}
5141
		return elem;
5142
	}
5143

5144
	if ( data == null && fn == null ) {
5145

5146
		// ( types, fn )
5147
		fn = selector;
5148
		data = selector = undefined;
5149
	} else if ( fn == null ) {
5150
		if ( typeof selector === "string" ) {
5151

5152
			// ( types, selector, fn )
5153
			fn = data;
5154
			data = undefined;
5155
		} else {
5156

5157
			// ( types, data, fn )
5158
			fn = data;
5159
			data = selector;
5160
			selector = undefined;
5161
		}
5162
	}
5163
	if ( fn === false ) {
5164
		fn = returnFalse;
5165
	} else if ( !fn ) {
5166
		return elem;
5167
	}
5168

5169
	if ( one === 1 ) {
5170
		origFn = fn;
5171
		fn = function( event ) {
5172

5173
			// Can use an empty set, since event contains the info
5174
			jQuery().off( event );
5175
			return origFn.apply( this, arguments );
5176
		};
5177

5178
		// Use same guid so caller can remove using origFn
5179
		fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
5180
	}
5181
	return elem.each( function() {
5182
		jQuery.event.add( this, types, fn, data, selector );
5183
	} );
5184
}
5185

5186
/*
5187
 * Helper functions for managing events -- not part of the public interface.
5188
 * Props to Dean Edwards' addEvent library for many of the ideas.
5189
 */
5190
jQuery.event = {
5191

5192
	global: {},
5193

5194
	add: function( elem, types, handler, data, selector ) {
5195

5196
		var handleObjIn, eventHandle, tmp,
5197
			events, t, handleObj,
5198
			special, handlers, type, namespaces, origType,
5199
			elemData = dataPriv.get( elem );
5200

5201
		// Only attach events to objects that accept data
5202
		if ( !acceptData( elem ) ) {
5203
			return;
5204
		}
5205

5206
		// Caller can pass in an object of custom data in lieu of the handler
5207
		if ( handler.handler ) {
5208
			handleObjIn = handler;
5209
			handler = handleObjIn.handler;
5210
			selector = handleObjIn.selector;
5211
		}
5212

5213
		// Ensure that invalid selectors throw exceptions at attach time
5214
		// Evaluate against documentElement in case elem is a non-element node (e.g., document)
5215
		if ( selector ) {
5216
			jQuery.find.matchesSelector( documentElement, selector );
5217
		}
5218

5219
		// Make sure that the handler has a unique ID, used to find/remove it later
5220
		if ( !handler.guid ) {
5221
			handler.guid = jQuery.guid++;
5222
		}
5223

5224
		// Init the element's event structure and main handler, if this is the first
5225
		if ( !( events = elemData.events ) ) {
5226
			events = elemData.events = Object.create( null );
5227
		}
5228
		if ( !( eventHandle = elemData.handle ) ) {
5229
			eventHandle = elemData.handle = function( e ) {
5230

5231
				// Discard the second event of a jQuery.event.trigger() and
5232
				// when an event is called after a page has unloaded
5233
				return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
5234
					jQuery.event.dispatch.apply( elem, arguments ) : undefined;
5235
			};
5236
		}
5237

5238
		// Handle multiple events separated by a space
5239
		types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
5240
		t = types.length;
5241
		while ( t-- ) {
5242
			tmp = rtypenamespace.exec( types[ t ] ) || [];
5243
			type = origType = tmp[ 1 ];
5244
			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
5245

5246
			// There *must* be a type, no attaching namespace-only handlers
5247
			if ( !type ) {
5248
				continue;
5249
			}
5250

5251
			// If event changes its type, use the special event handlers for the changed type
5252
			special = jQuery.event.special[ type ] || {};
5253

5254
			// If selector defined, determine special event api type, otherwise given type
5255
			type = ( selector ? special.delegateType : special.bindType ) || type;
5256

5257
			// Update special based on newly reset type
5258
			special = jQuery.event.special[ type ] || {};
5259

5260
			// handleObj is passed to all event handlers
5261
			handleObj = jQuery.extend( {
5262
				type: type,
5263
				origType: origType,
5264
				data: data,
5265
				handler: handler,
5266
				guid: handler.guid,
5267
				selector: selector,
5268
				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
5269
				namespace: namespaces.join( "." )
5270
			}, handleObjIn );
5271

5272
			// Init the event handler queue if we're the first
5273
			if ( !( handlers = events[ type ] ) ) {
5274
				handlers = events[ type ] = [];
5275
				handlers.delegateCount = 0;
5276

5277
				// Only use addEventListener if the special events handler returns false
5278
				if ( !special.setup ||
5279
					special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
5280

5281
					if ( elem.addEventListener ) {
5282
						elem.addEventListener( type, eventHandle );
5283
					}
5284
				}
5285
			}
5286

5287
			if ( special.add ) {
5288
				special.add.call( elem, handleObj );
5289

5290
				if ( !handleObj.handler.guid ) {
5291
					handleObj.handler.guid = handler.guid;
5292
				}
5293
			}
5294

5295
			// Add to the element's handler list, delegates in front
5296
			if ( selector ) {
5297
				handlers.splice( handlers.delegateCount++, 0, handleObj );
5298
			} else {
5299
				handlers.push( handleObj );
5300
			}
5301

5302
			// Keep track of which events have ever been used, for event optimization
5303
			jQuery.event.global[ type ] = true;
5304
		}
5305

5306
	},
5307

5308
	// Detach an event or set of events from an element
5309
	remove: function( elem, types, handler, selector, mappedTypes ) {
5310

5311
		var j, origCount, tmp,
5312
			events, t, handleObj,
5313
			special, handlers, type, namespaces, origType,
5314
			elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
5315

5316
		if ( !elemData || !( events = elemData.events ) ) {
5317
			return;
5318
		}
5319

5320
		// Once for each type.namespace in types; type may be omitted
5321
		types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
5322
		t = types.length;
5323
		while ( t-- ) {
5324
			tmp = rtypenamespace.exec( types[ t ] ) || [];
5325
			type = origType = tmp[ 1 ];
5326
			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
5327

5328
			// Unbind all events (on this namespace, if provided) for the element
5329
			if ( !type ) {
5330
				for ( type in events ) {
5331
					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
5332
				}
5333
				continue;
5334
			}
5335

5336
			special = jQuery.event.special[ type ] || {};
5337
			type = ( selector ? special.delegateType : special.bindType ) || type;
5338
			handlers = events[ type ] || [];
5339
			tmp = tmp[ 2 ] &&
5340
				new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
5341

5342
			// Remove matching events
5343
			origCount = j = handlers.length;
5344
			while ( j-- ) {
5345
				handleObj = handlers[ j ];
5346

5347
				if ( ( mappedTypes || origType === handleObj.origType ) &&
5348
					( !handler || handler.guid === handleObj.guid ) &&
5349
					( !tmp || tmp.test( handleObj.namespace ) ) &&
5350
					( !selector || selector === handleObj.selector ||
5351
						selector === "**" && handleObj.selector ) ) {
5352
					handlers.splice( j, 1 );
5353

5354
					if ( handleObj.selector ) {
5355
						handlers.delegateCount--;
5356
					}
5357
					if ( special.remove ) {
5358
						special.remove.call( elem, handleObj );
5359
					}
5360
				}
5361
			}
5362

5363
			// Remove generic event handler if we removed something and no more handlers exist
5364
			// (avoids potential for endless recursion during removal of special event handlers)
5365
			if ( origCount && !handlers.length ) {
5366
				if ( !special.teardown ||
5367
					special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
5368

5369
					jQuery.removeEvent( elem, type, elemData.handle );
5370
				}
5371

5372
				delete events[ type ];
5373
			}
5374
		}
5375

5376
		// Remove data and the expando if it's no longer used
5377
		if ( jQuery.isEmptyObject( events ) ) {
5378
			dataPriv.remove( elem, "handle events" );
5379
		}
5380
	},
5381

5382
	dispatch: function( nativeEvent ) {
5383

5384
		var i, j, ret, matched, handleObj, handlerQueue,
5385
			args = new Array( arguments.length ),
5386

5387
			// Make a writable jQuery.Event from the native event object
5388
			event = jQuery.event.fix( nativeEvent ),
5389

5390
			handlers = (
5391
				dataPriv.get( this, "events" ) || Object.create( null )
5392
			)[ event.type ] || [],
5393
			special = jQuery.event.special[ event.type ] || {};
5394

5395
		// Use the fix-ed jQuery.Event rather than the (read-only) native event
5396
		args[ 0 ] = event;
5397

5398
		for ( i = 1; i < arguments.length; i++ ) {
5399
			args[ i ] = arguments[ i ];
5400
		}
5401

5402
		event.delegateTarget = this;
5403

5404
		// Call the preDispatch hook for the mapped type, and let it bail if desired
5405
		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
5406
			return;
5407
		}
5408

5409
		// Determine handlers
5410
		handlerQueue = jQuery.event.handlers.call( this, event, handlers );
5411

5412
		// Run delegates first; they may want to stop propagation beneath us
5413
		i = 0;
5414
		while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
5415
			event.currentTarget = matched.elem;
5416

5417
			j = 0;
5418
			while ( ( handleObj = matched.handlers[ j++ ] ) &&
5419
				!event.isImmediatePropagationStopped() ) {
5420

5421
				// If the event is namespaced, then each handler is only invoked if it is
5422
				// specially universal or its namespaces are a superset of the event's.
5423
				if ( !event.rnamespace || handleObj.namespace === false ||
5424
					event.rnamespace.test( handleObj.namespace ) ) {
5425

5426
					event.handleObj = handleObj;
5427
					event.data = handleObj.data;
5428

5429
					ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
5430
						handleObj.handler ).apply( matched.elem, args );
5431

5432
					if ( ret !== undefined ) {
5433
						if ( ( event.result = ret ) === false ) {
5434
							event.preventDefault();
5435
							event.stopPropagation();
5436
						}
5437
					}
5438
				}
5439
			}
5440
		}
5441

5442
		// Call the postDispatch hook for the mapped type
5443
		if ( special.postDispatch ) {
5444
			special.postDispatch.call( this, event );
5445
		}
5446

5447
		return event.result;
5448
	},
5449

5450
	handlers: function( event, handlers ) {
5451
		var i, handleObj, sel, matchedHandlers, matchedSelectors,
5452
			handlerQueue = [],
5453
			delegateCount = handlers.delegateCount,
5454
			cur = event.target;
5455

5456
		// Find delegate handlers
5457
		if ( delegateCount &&
5458

5459
			// Support: IE <=9
5460
			// Black-hole SVG <use> instance trees (trac-13180)
5461
			cur.nodeType &&
5462

5463
			// Support: Firefox <=42
5464
			// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
5465
			// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
5466
			// Support: IE 11 only
5467
			// ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
5468
			!( event.type === "click" && event.button >= 1 ) ) {
5469

5470
			for ( ; cur !== this; cur = cur.parentNode || this ) {
5471

5472
				// Don't check non-elements (#13208)
5473
				// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
5474
				if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
5475
					matchedHandlers = [];
5476
					matchedSelectors = {};
5477
					for ( i = 0; i < delegateCount; i++ ) {
5478
						handleObj = handlers[ i ];
5479

5480
						// Don't conflict with Object.prototype properties (#13203)
5481
						sel = handleObj.selector + " ";
5482

5483
						if ( matchedSelectors[ sel ] === undefined ) {
5484
							matchedSelectors[ sel ] = handleObj.needsContext ?
5485
								jQuery( sel, this ).index( cur ) > -1 :
5486
								jQuery.find( sel, this, null, [ cur ] ).length;
5487
						}
5488
						if ( matchedSelectors[ sel ] ) {
5489
							matchedHandlers.push( handleObj );
5490
						}
5491
					}
5492
					if ( matchedHandlers.length ) {
5493
						handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
5494
					}
5495
				}
5496
			}
5497
		}
5498

5499
		// Add the remaining (directly-bound) handlers
5500
		cur = this;
5501
		if ( delegateCount < handlers.length ) {
5502
			handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
5503
		}
5504

5505
		return handlerQueue;
5506
	},
5507

5508
	addProp: function( name, hook ) {
5509
		Object.defineProperty( jQuery.Event.prototype, name, {
5510
			enumerable: true,
5511
			configurable: true,
5512

5513
			get: isFunction( hook ) ?
5514
				function() {
5515
					if ( this.originalEvent ) {
5516
						return hook( this.originalEvent );
5517
					}
5518
				} :
5519
				function() {
5520
					if ( this.originalEvent ) {
5521
						return this.originalEvent[ name ];
5522
					}
5523
				},
5524

5525
			set: function( value ) {
5526
				Object.defineProperty( this, name, {
5527
					enumerable: true,
5528
					configurable: true,
5529
					writable: true,
5530
					value: value
5531
				} );
5532
			}
5533
		} );
5534
	},
5535

5536
	fix: function( originalEvent ) {
5537
		return originalEvent[ jQuery.expando ] ?
5538
			originalEvent :
5539
			new jQuery.Event( originalEvent );
5540
	},
5541

5542
	special: {
5543
		load: {
5544

5545
			// Prevent triggered image.load events from bubbling to window.load
5546
			noBubble: true
5547
		},
5548
		click: {
5549

5550
			// Utilize native event to ensure correct state for checkable inputs
5551
			setup: function( data ) {
5552

5553
				// For mutual compressibility with _default, replace `this` access with a local var.
5554
				// `|| data` is dead code meant only to preserve the variable through minification.
5555
				var el = this || data;
5556

5557
				// Claim the first handler
5558
				if ( rcheckableType.test( el.type ) &&
5559
					el.click && nodeName( el, "input" ) ) {
5560

5561
					// dataPriv.set( el, "click", ... )
5562
					leverageNative( el, "click", returnTrue );
5563
				}
5564

5565
				// Return false to allow normal processing in the caller
5566
				return false;
5567
			},
5568
			trigger: function( data ) {
5569

5570
				// For mutual compressibility with _default, replace `this` access with a local var.
5571
				// `|| data` is dead code meant only to preserve the variable through minification.
5572
				var el = this || data;
5573

5574
				// Force setup before triggering a click
5575
				if ( rcheckableType.test( el.type ) &&
5576
					el.click && nodeName( el, "input" ) ) {
5577

5578
					leverageNative( el, "click" );
5579
				}
5580

5581
				// Return non-false to allow normal event-path propagation
5582
				return true;
5583
			},
5584

5585
			// For cross-browser consistency, suppress native .click() on links
5586
			// Also prevent it if we're currently inside a leveraged native-event stack
5587
			_default: function( event ) {
5588
				var target = event.target;
5589
				return rcheckableType.test( target.type ) &&
5590
					target.click && nodeName( target, "input" ) &&
5591
					dataPriv.get( target, "click" ) ||
5592
					nodeName( target, "a" );
5593
			}
5594
		},
5595

5596
		beforeunload: {
5597
			postDispatch: function( event ) {
5598

5599
				// Support: Firefox 20+
5600
				// Firefox doesn't alert if the returnValue field is not set.
5601
				if ( event.result !== undefined && event.originalEvent ) {
5602
					event.originalEvent.returnValue = event.result;
5603
				}
5604
			}
5605
		}
5606
	}
5607
};
5608

5609
// Ensure the presence of an event listener that handles manually-triggered
5610
// synthetic events by interrupting progress until reinvoked in response to
5611
// *native* events that it fires directly, ensuring that state changes have
5612
// already occurred before other listeners are invoked.
5613
function leverageNative( el, type, expectSync ) {
5614

5615
	// Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add
5616
	if ( !expectSync ) {
5617
		if ( dataPriv.get( el, type ) === undefined ) {
5618
			jQuery.event.add( el, type, returnTrue );
5619
		}
5620
		return;
5621
	}
5622

5623
	// Register the controller as a special universal handler for all event namespaces
5624
	dataPriv.set( el, type, false );
5625
	jQuery.event.add( el, type, {
5626
		namespace: false,
5627
		handler: function( event ) {
5628
			var notAsync, result,
5629
				saved = dataPriv.get( this, type );
5630

5631
			if ( ( event.isTrigger & 1 ) && this[ type ] ) {
5632

5633
				// Interrupt processing of the outer synthetic .trigger()ed event
5634
				// Saved data should be false in such cases, but might be a leftover capture object
5635
				// from an async native handler (gh-4350)
5636
				if ( !saved.length ) {
5637

5638
					// Store arguments for use when handling the inner native event
5639
					// There will always be at least one argument (an event object), so this array
5640
					// will not be confused with a leftover capture object.
5641
					saved = slice.call( arguments );
5642
					dataPriv.set( this, type, saved );
5643

5644
					// Trigger the native event and capture its result
5645
					// Support: IE <=9 - 11+
5646
					// focus() and blur() are asynchronous
5647
					notAsync = expectSync( this, type );
5648
					this[ type ]();
5649
					result = dataPriv.get( this, type );
5650
					if ( saved !== result || notAsync ) {
5651
						dataPriv.set( this, type, false );
5652
					} else {
5653
						result = {};
5654
					}
5655
					if ( saved !== result ) {
5656

5657
						// Cancel the outer synthetic event
5658
						event.stopImmediatePropagation();
5659
						event.preventDefault();
5660

5661
						// Support: Chrome 86+
5662
						// In Chrome, if an element having a focusout handler is blurred by
5663
						// clicking outside of it, it invokes the handler synchronously. If
5664
						// that handler calls `.remove()` on the element, the data is cleared,
5665
						// leaving `result` undefined. We need to guard against this.
5666
						return result && result.value;
5667
					}
5668

5669
				// If this is an inner synthetic event for an event with a bubbling surrogate
5670
				// (focus or blur), assume that the surrogate already propagated from triggering the
5671
				// native event and prevent that from happening again here.
5672
				// This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the
5673
				// bubbling surrogate propagates *after* the non-bubbling base), but that seems
5674
				// less bad than duplication.
5675
				} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {
5676
					event.stopPropagation();
5677
				}
5678

5679
			// If this is a native event triggered above, everything is now in order
5680
			// Fire an inner synthetic event with the original arguments
5681
			} else if ( saved.length ) {
5682

5683
				// ...and capture the result
5684
				dataPriv.set( this, type, {
5685
					value: jQuery.event.trigger(
5686

5687
						// Support: IE <=9 - 11+
5688
						// Extend with the prototype to reset the above stopImmediatePropagation()
5689
						jQuery.extend( saved[ 0 ], jQuery.Event.prototype ),
5690
						saved.slice( 1 ),
5691
						this
5692
					)
5693
				} );
5694

5695
				// Abort handling of the native event
5696
				event.stopImmediatePropagation();
5697
			}
5698
		}
5699
	} );
5700
}
5701

5702
jQuery.removeEvent = function( elem, type, handle ) {
5703

5704
	// This "if" is needed for plain objects
5705
	if ( elem.removeEventListener ) {
5706
		elem.removeEventListener( type, handle );
5707
	}
5708
};
5709

5710
jQuery.Event = function( src, props ) {
5711

5712
	// Allow instantiation without the 'new' keyword
5713
	if ( !( this instanceof jQuery.Event ) ) {
5714
		return new jQuery.Event( src, props );
5715
	}
5716

5717
	// Event object
5718
	if ( src && src.type ) {
5719
		this.originalEvent = src;
5720
		this.type = src.type;
5721

5722
		// Events bubbling up the document may have been marked as prevented
5723
		// by a handler lower down the tree; reflect the correct value.
5724
		this.isDefaultPrevented = src.defaultPrevented ||
5725
				src.defaultPrevented === undefined &&
5726

5727
				// Support: Android <=2.3 only
5728
				src.returnValue === false ?
5729
			returnTrue :
5730
			returnFalse;
5731

5732
		// Create target properties
5733
		// Support: Safari <=6 - 7 only
5734
		// Target should not be a text node (#504, #13143)
5735
		this.target = ( src.target && src.target.nodeType === 3 ) ?
5736
			src.target.parentNode :
5737
			src.target;
5738

5739
		this.currentTarget = src.currentTarget;
5740
		this.relatedTarget = src.relatedTarget;
5741

5742
	// Event type
5743
	} else {
5744
		this.type = src;
5745
	}
5746

5747
	// Put explicitly provided properties onto the event object
5748
	if ( props ) {
5749
		jQuery.extend( this, props );
5750
	}
5751

5752
	// Create a timestamp if incoming event doesn't have one
5753
	this.timeStamp = src && src.timeStamp || Date.now();
5754

5755
	// Mark it as fixed
5756
	this[ jQuery.expando ] = true;
5757
};
5758

5759
// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
5760
// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
5761
jQuery.Event.prototype = {
5762
	constructor: jQuery.Event,
5763
	isDefaultPrevented: returnFalse,
5764
	isPropagationStopped: returnFalse,
5765
	isImmediatePropagationStopped: returnFalse,
5766
	isSimulated: false,
5767

5768
	preventDefault: function() {
5769
		var e = this.originalEvent;
5770

5771
		this.isDefaultPrevented = returnTrue;
5772

5773
		if ( e && !this.isSimulated ) {
5774
			e.preventDefault();
5775
		}
5776
	},
5777
	stopPropagation: function() {
5778
		var e = this.originalEvent;
5779

5780
		this.isPropagationStopped = returnTrue;
5781

5782
		if ( e && !this.isSimulated ) {
5783
			e.stopPropagation();
5784
		}
5785
	},
5786
	stopImmediatePropagation: function() {
5787
		var e = this.originalEvent;
5788

5789
		this.isImmediatePropagationStopped = returnTrue;
5790

5791
		if ( e && !this.isSimulated ) {
5792
			e.stopImmediatePropagation();
5793
		}
5794

5795
		this.stopPropagation();
5796
	}
5797
};
5798

5799
// Includes all common event props including KeyEvent and MouseEvent specific props
5800
jQuery.each( {
5801
	altKey: true,
5802
	bubbles: true,
5803
	cancelable: true,
5804
	changedTouches: true,
5805
	ctrlKey: true,
5806
	detail: true,
5807
	eventPhase: true,
5808
	metaKey: true,
5809
	pageX: true,
5810
	pageY: true,
5811
	shiftKey: true,
5812
	view: true,
5813
	"char": true,
5814
	code: true,
5815
	charCode: true,
5816
	key: true,
5817
	keyCode: true,
5818
	button: true,
5819
	buttons: true,
5820
	clientX: true,
5821
	clientY: true,
5822
	offsetX: true,
5823
	offsetY: true,
5824
	pointerId: true,
5825
	pointerType: true,
5826
	screenX: true,
5827
	screenY: true,
5828
	targetTouches: true,
5829
	toElement: true,
5830
	touches: true,
5831
	which: true
5832
}, jQuery.event.addProp );
5833

5834
jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) {
5835
	jQuery.event.special[ type ] = {
5836

5837
		// Utilize native event if possible so blur/focus sequence is correct
5838
		setup: function() {
5839

5840
			// Claim the first handler
5841
			// dataPriv.set( this, "focus", ... )
5842
			// dataPriv.set( this, "blur", ... )
5843
			leverageNative( this, type, expectSync );
5844

5845
			// Return false to allow normal processing in the caller
5846
			return false;
5847
		},
5848
		trigger: function() {
5849

5850
			// Force setup before trigger
5851
			leverageNative( this, type );
5852

5853
			// Return non-false to allow normal event-path propagation
5854
			return true;
5855
		},
5856

5857
		// Suppress native focus or blur as it's already being fired
5858
		// in leverageNative.
5859
		_default: function() {
5860
			return true;
5861
		},
5862

5863
		delegateType: delegateType
5864
	};
5865
} );
5866

5867
// Create mouseenter/leave events using mouseover/out and event-time checks
5868
// so that event delegation works in jQuery.
5869
// Do the same for pointerenter/pointerleave and pointerover/pointerout
5870
//
5871
// Support: Safari 7 only
5872
// Safari sends mouseenter too often; see:
5873
// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
5874
// for the description of the bug (it existed in older Chrome versions as well).
5875
jQuery.each( {
5876
	mouseenter: "mouseover",
5877
	mouseleave: "mouseout",
5878
	pointerenter: "pointerover",
5879
	pointerleave: "pointerout"
5880
}, function( orig, fix ) {
5881
	jQuery.event.special[ orig ] = {
5882
		delegateType: fix,
5883
		bindType: fix,
5884

5885
		handle: function( event ) {
5886
			var ret,
5887
				target = this,
5888
				related = event.relatedTarget,
5889
				handleObj = event.handleObj;
5890

5891
			// For mouseenter/leave call the handler if related is outside the target.
5892
			// NB: No relatedTarget if the mouse left/entered the browser window
5893
			if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
5894
				event.type = handleObj.origType;
5895
				ret = handleObj.handler.apply( this, arguments );
5896
				event.type = fix;
5897
			}
5898
			return ret;
5899
		}
5900
	};
5901
} );
5902

5903
jQuery.fn.extend( {
5904

5905
	on: function( types, selector, data, fn ) {
5906
		return on( this, types, selector, data, fn );
5907
	},
5908
	one: function( types, selector, data, fn ) {
5909
		return on( this, types, selector, data, fn, 1 );
5910
	},
5911
	off: function( types, selector, fn ) {
5912
		var handleObj, type;
5913
		if ( types && types.preventDefault && types.handleObj ) {
5914

5915
			// ( event )  dispatched jQuery.Event
5916
			handleObj = types.handleObj;
5917
			jQuery( types.delegateTarget ).off(
5918
				handleObj.namespace ?
5919
					handleObj.origType + "." + handleObj.namespace :
5920
					handleObj.origType,
5921
				handleObj.selector,
5922
				handleObj.handler
5923
			);
5924
			return this;
5925
		}
5926
		if ( typeof types === "object" ) {
5927

5928
			// ( types-object [, selector] )
5929
			for ( type in types ) {
5930
				this.off( type, selector, types[ type ] );
5931
			}
5932
			return this;
5933
		}
5934
		if ( selector === false || typeof selector === "function" ) {
5935

5936
			// ( types [, fn] )
5937
			fn = selector;
5938
			selector = undefined;
5939
		}
5940
		if ( fn === false ) {
5941
			fn = returnFalse;
5942
		}
5943
		return this.each( function() {
5944
			jQuery.event.remove( this, types, fn, selector );
5945
		} );
5946
	}
5947
} );
5948

5949

5950
var
5951

5952
	// Support: IE <=10 - 11, Edge 12 - 13 only
5953
	// In IE/Edge using regex groups here causes severe slowdowns.
5954
	// See https://connect.microsoft.com/IE/feedback/details/1736512/
5955
	rnoInnerhtml = /<script|<style|<link/i,
5956

5957
	// checked="checked" or checked
5958
	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5959
	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
5960

5961
// Prefer a tbody over its parent table for containing new rows
5962
function manipulationTarget( elem, content ) {
5963
	if ( nodeName( elem, "table" ) &&
5964
		nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
5965

5966
		return jQuery( elem ).children( "tbody" )[ 0 ] || elem;
5967
	}
5968

5969
	return elem;
5970
}
5971

5972
// Replace/restore the type attribute of script elements for safe DOM manipulation
5973
function disableScript( elem ) {
5974
	elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
5975
	return elem;
5976
}
5977
function restoreScript( elem ) {
5978
	if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) {
5979
		elem.type = elem.type.slice( 5 );
5980
	} else {
5981
		elem.removeAttribute( "type" );
5982
	}
5983

5984
	return elem;
5985
}
5986

5987
function cloneCopyEvent( src, dest ) {
5988
	var i, l, type, pdataOld, udataOld, udataCur, events;
5989

5990
	if ( dest.nodeType !== 1 ) {
5991
		return;
5992
	}
5993

5994
	// 1. Copy private data: events, handlers, etc.
5995
	if ( dataPriv.hasData( src ) ) {
5996
		pdataOld = dataPriv.get( src );
5997
		events = pdataOld.events;
5998

5999
		if ( events ) {
6000
			dataPriv.remove( dest, "handle events" );
6001

6002
			for ( type in events ) {
6003
				for ( i = 0, l = events[ type ].length; i < l; i++ ) {
6004
					jQuery.event.add( dest, type, events[ type ][ i ] );
6005
				}
6006
			}
6007
		}
6008
	}
6009

6010
	// 2. Copy user data
6011
	if ( dataUser.hasData( src ) ) {
6012
		udataOld = dataUser.access( src );
6013
		udataCur = jQuery.extend( {}, udataOld );
6014

6015
		dataUser.set( dest, udataCur );
6016
	}
6017
}
6018

6019
// Fix IE bugs, see support tests
6020
function fixInput( src, dest ) {
6021
	var nodeName = dest.nodeName.toLowerCase();
6022

6023
	// Fails to persist the checked state of a cloned checkbox or radio button.
6024
	if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
6025
		dest.checked = src.checked;
6026

6027
	// Fails to return the selected option to the default selected state when cloning options
6028
	} else if ( nodeName === "input" || nodeName === "textarea" ) {
6029
		dest.defaultValue = src.defaultValue;
6030
	}
6031
}
6032

6033
function domManip( collection, args, callback, ignored ) {
6034

6035
	// Flatten any nested arrays
6036
	args = flat( args );
6037

6038
	var fragment, first, scripts, hasScripts, node, doc,
6039
		i = 0,
6040
		l = collection.length,
6041
		iNoClone = l - 1,
6042
		value = args[ 0 ],
6043
		valueIsFunction = isFunction( value );
6044

6045
	// We can't cloneNode fragments that contain checked, in WebKit
6046
	if ( valueIsFunction ||
6047
			( l > 1 && typeof value === "string" &&
6048
				!support.checkClone && rchecked.test( value ) ) ) {
6049
		return collection.each( function( index ) {
6050
			var self = collection.eq( index );
6051
			if ( valueIsFunction ) {
6052
				args[ 0 ] = value.call( this, index, self.html() );
6053
			}
6054
			domManip( self, args, callback, ignored );
6055
		} );
6056
	}
6057

6058
	if ( l ) {
6059
		fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
6060
		first = fragment.firstChild;
6061

6062
		if ( fragment.childNodes.length === 1 ) {
6063
			fragment = first;
6064
		}
6065

6066
		// Require either new content or an interest in ignored elements to invoke the callback
6067
		if ( first || ignored ) {
6068
			scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
6069
			hasScripts = scripts.length;
6070

6071
			// Use the original fragment for the last item
6072
			// instead of the first because it can end up
6073
			// being emptied incorrectly in certain situations (#8070).
6074
			for ( ; i < l; i++ ) {
6075
				node = fragment;
6076

6077
				if ( i !== iNoClone ) {
6078
					node = jQuery.clone( node, true, true );
6079

6080
					// Keep references to cloned scripts for later restoration
6081
					if ( hasScripts ) {
6082

6083
						// Support: Android <=4.0 only, PhantomJS 1 only
6084
						// push.apply(_, arraylike) throws on ancient WebKit
6085
						jQuery.merge( scripts, getAll( node, "script" ) );
6086
					}
6087
				}
6088

6089
				callback.call( collection[ i ], node, i );
6090
			}
6091

6092
			if ( hasScripts ) {
6093
				doc = scripts[ scripts.length - 1 ].ownerDocument;
6094

6095
				// Reenable scripts
6096
				jQuery.map( scripts, restoreScript );
6097

6098
				// Evaluate executable scripts on first document insertion
6099
				for ( i = 0; i < hasScripts; i++ ) {
6100
					node = scripts[ i ];
6101
					if ( rscriptType.test( node.type || "" ) &&
6102
						!dataPriv.access( node, "globalEval" ) &&
6103
						jQuery.contains( doc, node ) ) {
6104

6105
						if ( node.src && ( node.type || "" ).toLowerCase()  !== "module" ) {
6106

6107
							// Optional AJAX dependency, but won't run scripts if not present
6108
							if ( jQuery._evalUrl && !node.noModule ) {
6109
								jQuery._evalUrl( node.src, {
6110
									nonce: node.nonce || node.getAttribute( "nonce" )
6111
								}, doc );
6112
							}
6113
						} else {
6114
							DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc );
6115
						}
6116
					}
6117
				}
6118
			}
6119
		}
6120
	}
6121

6122
	return collection;
6123
}
6124

6125
function remove( elem, selector, keepData ) {
6126
	var node,
6127
		nodes = selector ? jQuery.filter( selector, elem ) : elem,
6128
		i = 0;
6129

6130
	for ( ; ( node = nodes[ i ] ) != null; i++ ) {
6131
		if ( !keepData && node.nodeType === 1 ) {
6132
			jQuery.cleanData( getAll( node ) );
6133
		}
6134

6135
		if ( node.parentNode ) {
6136
			if ( keepData && isAttached( node ) ) {
6137
				setGlobalEval( getAll( node, "script" ) );
6138
			}
6139
			node.parentNode.removeChild( node );
6140
		}
6141
	}
6142

6143
	return elem;
6144
}
6145

6146
jQuery.extend( {
6147
	htmlPrefilter: function( html ) {
6148
		return html;
6149
	},
6150

6151
	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
6152
		var i, l, srcElements, destElements,
6153
			clone = elem.cloneNode( true ),
6154
			inPage = isAttached( elem );
6155

6156
		// Fix IE cloning issues
6157
		if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
6158
				!jQuery.isXMLDoc( elem ) ) {
6159

6160
			// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
6161
			destElements = getAll( clone );
6162
			srcElements = getAll( elem );
6163

6164
			for ( i = 0, l = srcElements.length; i < l; i++ ) {
6165
				fixInput( srcElements[ i ], destElements[ i ] );
6166
			}
6167
		}
6168

6169
		// Copy the events from the original to the clone
6170
		if ( dataAndEvents ) {
6171
			if ( deepDataAndEvents ) {
6172
				srcElements = srcElements || getAll( elem );
6173
				destElements = destElements || getAll( clone );
6174

6175
				for ( i = 0, l = srcElements.length; i < l; i++ ) {
6176
					cloneCopyEvent( srcElements[ i ], destElements[ i ] );
6177
				}
6178
			} else {
6179
				cloneCopyEvent( elem, clone );
6180
			}
6181
		}
6182

6183
		// Preserve script evaluation history
6184
		destElements = getAll( clone, "script" );
6185
		if ( destElements.length > 0 ) {
6186
			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
6187
		}
6188

6189
		// Return the cloned set
6190
		return clone;
6191
	},
6192

6193
	cleanData: function( elems ) {
6194
		var data, elem, type,
6195
			special = jQuery.event.special,
6196
			i = 0;
6197

6198
		for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
6199
			if ( acceptData( elem ) ) {
6200
				if ( ( data = elem[ dataPriv.expando ] ) ) {
6201
					if ( data.events ) {
6202
						for ( type in data.events ) {
6203
							if ( special[ type ] ) {
6204
								jQuery.event.remove( elem, type );
6205

6206
							// This is a shortcut to avoid jQuery.event.remove's overhead
6207
							} else {
6208
								jQuery.removeEvent( elem, type, data.handle );
6209
							}
6210
						}
6211
					}
6212

6213
					// Support: Chrome <=35 - 45+
6214
					// Assign undefined instead of using delete, see Data#remove
6215
					elem[ dataPriv.expando ] = undefined;
6216
				}
6217
				if ( elem[ dataUser.expando ] ) {
6218

6219
					// Support: Chrome <=35 - 45+
6220
					// Assign undefined instead of using delete, see Data#remove
6221
					elem[ dataUser.expando ] = undefined;
6222
				}
6223
			}
6224
		}
6225
	}
6226
} );
6227

6228
jQuery.fn.extend( {
6229
	detach: function( selector ) {
6230
		return remove( this, selector, true );
6231
	},
6232

6233
	remove: function( selector ) {
6234
		return remove( this, selector );
6235
	},
6236

6237
	text: function( value ) {
6238
		return access( this, function( value ) {
6239
			return value === undefined ?
6240
				jQuery.text( this ) :
6241
				this.empty().each( function() {
6242
					if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
6243
						this.textContent = value;
6244
					}
6245
				} );
6246
		}, null, value, arguments.length );
6247
	},
6248

6249
	append: function() {
6250
		return domManip( this, arguments, function( elem ) {
6251
			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
6252
				var target = manipulationTarget( this, elem );
6253
				target.appendChild( elem );
6254
			}
6255
		} );
6256
	},
6257

6258
	prepend: function() {
6259
		return domManip( this, arguments, function( elem ) {
6260
			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
6261
				var target = manipulationTarget( this, elem );
6262
				target.insertBefore( elem, target.firstChild );
6263
			}
6264
		} );
6265
	},
6266

6267
	before: function() {
6268
		return domManip( this, arguments, function( elem ) {
6269
			if ( this.parentNode ) {
6270
				this.parentNode.insertBefore( elem, this );
6271
			}
6272
		} );
6273
	},
6274

6275
	after: function() {
6276
		return domManip( this, arguments, function( elem ) {
6277
			if ( this.parentNode ) {
6278
				this.parentNode.insertBefore( elem, this.nextSibling );
6279
			}
6280
		} );
6281
	},
6282

6283
	empty: function() {
6284
		var elem,
6285
			i = 0;
6286

6287
		for ( ; ( elem = this[ i ] ) != null; i++ ) {
6288
			if ( elem.nodeType === 1 ) {
6289

6290
				// Prevent memory leaks
6291
				jQuery.cleanData( getAll( elem, false ) );
6292

6293
				// Remove any remaining nodes
6294
				elem.textContent = "";
6295
			}
6296
		}
6297

6298
		return this;
6299
	},
6300

6301
	clone: function( dataAndEvents, deepDataAndEvents ) {
6302
		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
6303
		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
6304

6305
		return this.map( function() {
6306
			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
6307
		} );
6308
	},
6309

6310
	html: function( value ) {
6311
		return access( this, function( value ) {
6312
			var elem = this[ 0 ] || {},
6313
				i = 0,
6314
				l = this.length;
6315

6316
			if ( value === undefined && elem.nodeType === 1 ) {
6317
				return elem.innerHTML;
6318
			}
6319

6320
			// See if we can take a shortcut and just use innerHTML
6321
			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
6322
				!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
6323

6324
				value = jQuery.htmlPrefilter( value );
6325

6326
				try {
6327
					for ( ; i < l; i++ ) {
6328
						elem = this[ i ] || {};
6329

6330
						// Remove element nodes and prevent memory leaks
6331
						if ( elem.nodeType === 1 ) {
6332
							jQuery.cleanData( getAll( elem, false ) );
6333
							elem.innerHTML = value;
6334
						}
6335
					}
6336

6337
					elem = 0;
6338

6339
				// If using innerHTML throws an exception, use the fallback method
6340
				} catch ( e ) {}
6341
			}
6342

6343
			if ( elem ) {
6344
				this.empty().append( value );
6345
			}
6346
		}, null, value, arguments.length );
6347
	},
6348

6349
	replaceWith: function() {
6350
		var ignored = [];
6351

6352
		// Make the changes, replacing each non-ignored context element with the new content
6353
		return domManip( this, arguments, function( elem ) {
6354
			var parent = this.parentNode;
6355

6356
			if ( jQuery.inArray( this, ignored ) < 0 ) {
6357
				jQuery.cleanData( getAll( this ) );
6358
				if ( parent ) {
6359
					parent.replaceChild( elem, this );
6360
				}
6361
			}
6362

6363
		// Force callback invocation
6364
		}, ignored );
6365
	}
6366
} );
6367

6368
jQuery.each( {
6369
	appendTo: "append",
6370
	prependTo: "prepend",
6371
	insertBefore: "before",
6372
	insertAfter: "after",
6373
	replaceAll: "replaceWith"
6374
}, function( name, original ) {
6375
	jQuery.fn[ name ] = function( selector ) {
6376
		var elems,
6377
			ret = [],
6378
			insert = jQuery( selector ),
6379
			last = insert.length - 1,
6380
			i = 0;
6381

6382
		for ( ; i <= last; i++ ) {
6383
			elems = i === last ? this : this.clone( true );
6384
			jQuery( insert[ i ] )[ original ]( elems );
6385

6386
			// Support: Android <=4.0 only, PhantomJS 1 only
6387
			// .get() because push.apply(_, arraylike) throws on ancient WebKit
6388
			push.apply( ret, elems.get() );
6389
		}
6390

6391
		return this.pushStack( ret );
6392
	};
6393
} );
6394
var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
6395

6396
var getStyles = function( elem ) {
6397

6398
		// Support: IE <=11 only, Firefox <=30 (#15098, #14150)
6399
		// IE throws on elements created in popups
6400
		// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
6401
		var view = elem.ownerDocument.defaultView;
6402

6403
		if ( !view || !view.opener ) {
6404
			view = window;
6405
		}
6406

6407
		return view.getComputedStyle( elem );
6408
	};
6409

6410
var swap = function( elem, options, callback ) {
6411
	var ret, name,
6412
		old = {};
6413

6414
	// Remember the old values, and insert the new ones
6415
	for ( name in options ) {
6416
		old[ name ] = elem.style[ name ];
6417
		elem.style[ name ] = options[ name ];
6418
	}
6419

6420
	ret = callback.call( elem );
6421

6422
	// Revert the old values
6423
	for ( name in options ) {
6424
		elem.style[ name ] = old[ name ];
6425
	}
6426

6427
	return ret;
6428
};
6429

6430

6431
var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );
6432

6433

6434

6435
( function() {
6436

6437
	// Executing both pixelPosition & boxSizingReliable tests require only one layout
6438
	// so they're executed at the same time to save the second computation.
6439
	function computeStyleTests() {
6440

6441
		// This is a singleton, we need to execute it only once
6442
		if ( !div ) {
6443
			return;
6444
		}
6445

6446
		container.style.cssText = "position:absolute;left:-11111px;width:60px;" +
6447
			"margin-top:1px;padding:0;border:0";
6448
		div.style.cssText =
6449
			"position:relative;display:block;box-sizing:border-box;overflow:scroll;" +
6450
			"margin:auto;border:1px;padding:1px;" +
6451
			"width:60%;top:1%";
6452
		documentElement.appendChild( container ).appendChild( div );
6453

6454
		var divStyle = window.getComputedStyle( div );
6455
		pixelPositionVal = divStyle.top !== "1%";
6456

6457
		// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
6458
		reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;
6459

6460
		// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
6461
		// Some styles come back with percentage values, even though they shouldn't
6462
		div.style.right = "60%";
6463
		pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;
6464

6465
		// Support: IE 9 - 11 only
6466
		// Detect misreporting of content dimensions for box-sizing:border-box elements
6467
		boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;
6468

6469
		// Support: IE 9 only
6470
		// Detect overflow:scroll screwiness (gh-3699)
6471
		// Support: Chrome <=64
6472
		// Don't get tricked when zoom affects offsetWidth (gh-4029)
6473
		div.style.position = "absolute";
6474
		scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;
6475

6476
		documentElement.removeChild( container );
6477

6478
		// Nullify the div so it wouldn't be stored in the memory and
6479
		// it will also be a sign that checks already performed
6480
		div = null;
6481
	}
6482

6483
	function roundPixelMeasures( measure ) {
6484
		return Math.round( parseFloat( measure ) );
6485
	}
6486

6487
	var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,
6488
		reliableTrDimensionsVal, reliableMarginLeftVal,
6489
		container = document.createElement( "div" ),
6490
		div = document.createElement( "div" );
6491

6492
	// Finish early in limited (non-browser) environments
6493
	if ( !div.style ) {
6494
		return;
6495
	}
6496

6497
	// Support: IE <=9 - 11 only
6498
	// Style of cloned element affects source element cloned (#8908)
6499
	div.style.backgroundClip = "content-box";
6500
	div.cloneNode( true ).style.backgroundClip = "";
6501
	support.clearCloneStyle = div.style.backgroundClip === "content-box";
6502

6503
	jQuery.extend( support, {
6504
		boxSizingReliable: function() {
6505
			computeStyleTests();
6506
			return boxSizingReliableVal;
6507
		},
6508
		pixelBoxStyles: function() {
6509
			computeStyleTests();
6510
			return pixelBoxStylesVal;
6511
		},
6512
		pixelPosition: function() {
6513
			computeStyleTests();
6514
			return pixelPositionVal;
6515
		},
6516
		reliableMarginLeft: function() {
6517
			computeStyleTests();
6518
			return reliableMarginLeftVal;
6519
		},
6520
		scrollboxSize: function() {
6521
			computeStyleTests();
6522
			return scrollboxSizeVal;
6523
		},
6524

6525
		// Support: IE 9 - 11+, Edge 15 - 18+
6526
		// IE/Edge misreport `getComputedStyle` of table rows with width/height
6527
		// set in CSS while `offset*` properties report correct values.
6528
		// Behavior in IE 9 is more subtle than in newer versions & it passes
6529
		// some versions of this test; make sure not to make it pass there!
6530
		//
6531
		// Support: Firefox 70+
6532
		// Only Firefox includes border widths
6533
		// in computed dimensions. (gh-4529)
6534
		reliableTrDimensions: function() {
6535
			var table, tr, trChild, trStyle;
6536
			if ( reliableTrDimensionsVal == null ) {
6537
				table = document.createElement( "table" );
6538
				tr = document.createElement( "tr" );
6539
				trChild = document.createElement( "div" );
6540

6541
				table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate";
6542
				tr.style.cssText = "border:1px solid";
6543

6544
				// Support: Chrome 86+
6545
				// Height set through cssText does not get applied.
6546
				// Computed height then comes back as 0.
6547
				tr.style.height = "1px";
6548
				trChild.style.height = "9px";
6549

6550
				// Support: Android 8 Chrome 86+
6551
				// In our bodyBackground.html iframe,
6552
				// display for all div elements is set to "inline",
6553
				// which causes a problem only in Android 8 Chrome 86.
6554
				// Ensuring the div is display: block
6555
				// gets around this issue.
6556
				trChild.style.display = "block";
6557

6558
				documentElement
6559
					.appendChild( table )
6560
					.appendChild( tr )
6561
					.appendChild( trChild );
6562

6563
				trStyle = window.getComputedStyle( tr );
6564
				reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +
6565
					parseInt( trStyle.borderTopWidth, 10 ) +
6566
					parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;
6567

6568
				documentElement.removeChild( table );
6569
			}
6570
			return reliableTrDimensionsVal;
6571
		}
6572
	} );
6573
} )();
6574

6575

6576
function curCSS( elem, name, computed ) {
6577
	var width, minWidth, maxWidth, ret,
6578

6579
		// Support: Firefox 51+
6580
		// Retrieving style before computed somehow
6581
		// fixes an issue with getting wrong values
6582
		// on detached elements
6583
		style = elem.style;
6584

6585
	computed = computed || getStyles( elem );
6586

6587
	// getPropertyValue is needed for:
6588
	//   .css('filter') (IE 9 only, #12537)
6589
	//   .css('--customProperty) (#3144)
6590
	if ( computed ) {
6591
		ret = computed.getPropertyValue( name ) || computed[ name ];
6592

6593
		if ( ret === "" && !isAttached( elem ) ) {
6594
			ret = jQuery.style( elem, name );
6595
		}
6596

6597
		// A tribute to the "awesome hack by Dean Edwards"
6598
		// Android Browser returns percentage for some values,
6599
		// but width seems to be reliably pixels.
6600
		// This is against the CSSOM draft spec:
6601
		// https://drafts.csswg.org/cssom/#resolved-values
6602
		if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {
6603

6604
			// Remember the original values
6605
			width = style.width;
6606
			minWidth = style.minWidth;
6607
			maxWidth = style.maxWidth;
6608

6609
			// Put in the new values to get a computed value out
6610
			style.minWidth = style.maxWidth = style.width = ret;
6611
			ret = computed.width;
6612

6613
			// Revert the changed values
6614
			style.width = width;
6615
			style.minWidth = minWidth;
6616
			style.maxWidth = maxWidth;
6617
		}
6618
	}
6619

6620
	return ret !== undefined ?
6621

6622
		// Support: IE <=9 - 11 only
6623
		// IE returns zIndex value as an integer.
6624
		ret + "" :
6625
		ret;
6626
}
6627

6628

6629
function addGetHookIf( conditionFn, hookFn ) {
6630

6631
	// Define the hook, we'll check on the first run if it's really needed.
6632
	return {
6633
		get: function() {
6634
			if ( conditionFn() ) {
6635

6636
				// Hook not needed (or it's not possible to use it due
6637
				// to missing dependency), remove it.
6638
				delete this.get;
6639
				return;
6640
			}
6641

6642
			// Hook needed; redefine it so that the support test is not executed again.
6643
			return ( this.get = hookFn ).apply( this, arguments );
6644
		}
6645
	};
6646
}
6647

6648

6649
var cssPrefixes = [ "Webkit", "Moz", "ms" ],
6650
	emptyStyle = document.createElement( "div" ).style,
6651
	vendorProps = {};
6652

6653
// Return a vendor-prefixed property or undefined
6654
function vendorPropName( name ) {
6655

6656
	// Check for vendor prefixed names
6657
	var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
6658
		i = cssPrefixes.length;
6659

6660
	while ( i-- ) {
6661
		name = cssPrefixes[ i ] + capName;
6662
		if ( name in emptyStyle ) {
6663
			return name;
6664
		}
6665
	}
6666
}
6667

6668
// Return a potentially-mapped jQuery.cssProps or vendor prefixed property
6669
function finalPropName( name ) {
6670
	var final = jQuery.cssProps[ name ] || vendorProps[ name ];
6671

6672
	if ( final ) {
6673
		return final;
6674
	}
6675
	if ( name in emptyStyle ) {
6676
		return name;
6677
	}
6678
	return vendorProps[ name ] = vendorPropName( name ) || name;
6679
}
6680

6681

6682
var
6683

6684
	// Swappable if display is none or starts with table
6685
	// except "table", "table-cell", or "table-caption"
6686
	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
6687
	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
6688
	rcustomProp = /^--/,
6689
	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
6690
	cssNormalTransform = {
6691
		letterSpacing: "0",
6692
		fontWeight: "400"
6693
	};
6694

6695
function setPositiveNumber( _elem, value, subtract ) {
6696

6697
	// Any relative (+/-) values have already been
6698
	// normalized at this point
6699
	var matches = rcssNum.exec( value );
6700
	return matches ?
6701

6702
		// Guard against undefined "subtract", e.g., when used as in cssHooks
6703
		Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
6704
		value;
6705
}
6706

6707
function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
6708
	var i = dimension === "width" ? 1 : 0,
6709
		extra = 0,
6710
		delta = 0;
6711

6712
	// Adjustment may not be necessary
6713
	if ( box === ( isBorderBox ? "border" : "content" ) ) {
6714
		return 0;
6715
	}
6716

6717
	for ( ; i < 4; i += 2 ) {
6718

6719
		// Both box models exclude margin
6720
		if ( box === "margin" ) {
6721
			delta += jQuery.css( elem, box + cssExpand[ i ], true, styles );
6722
		}
6723

6724
		// If we get here with a content-box, we're seeking "padding" or "border" or "margin"
6725
		if ( !isBorderBox ) {
6726

6727
			// Add padding
6728
			delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6729

6730
			// For "border" or "margin", add border
6731
			if ( box !== "padding" ) {
6732
				delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6733

6734
			// But still keep track of it otherwise
6735
			} else {
6736
				extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6737
			}
6738

6739
		// If we get here with a border-box (content + padding + border), we're seeking "content" or
6740
		// "padding" or "margin"
6741
		} else {
6742

6743
			// For "content", subtract padding
6744
			if ( box === "content" ) {
6745
				delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6746
			}
6747

6748
			// For "content" or "padding", subtract border
6749
			if ( box !== "margin" ) {
6750
				delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6751
			}
6752
		}
6753
	}
6754

6755
	// Account for positive content-box scroll gutter when requested by providing computedVal
6756
	if ( !isBorderBox && computedVal >= 0 ) {
6757

6758
		// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
6759
		// Assuming integer scroll gutter, subtract the rest and round down
6760
		delta += Math.max( 0, Math.ceil(
6761
			elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
6762
			computedVal -
6763
			delta -
6764
			extra -
6765
			0.5
6766

6767
		// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter
6768
		// Use an explicit zero to avoid NaN (gh-3964)
6769
		) ) || 0;
6770
	}
6771

6772
	return delta;
6773
}
6774

6775
function getWidthOrHeight( elem, dimension, extra ) {
6776

6777
	// Start with computed style
6778
	var styles = getStyles( elem ),
6779

6780
		// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).
6781
		// Fake content-box until we know it's needed to know the true value.
6782
		boxSizingNeeded = !support.boxSizingReliable() || extra,
6783
		isBorderBox = boxSizingNeeded &&
6784
			jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
6785
		valueIsBorderBox = isBorderBox,
6786

6787
		val = curCSS( elem, dimension, styles ),
6788
		offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );
6789

6790
	// Support: Firefox <=54
6791
	// Return a confounding non-pixel value or feign ignorance, as appropriate.
6792
	if ( rnumnonpx.test( val ) ) {
6793
		if ( !extra ) {
6794
			return val;
6795
		}
6796
		val = "auto";
6797
	}
6798

6799

6800
	// Support: IE 9 - 11 only
6801
	// Use offsetWidth/offsetHeight for when box sizing is unreliable.
6802
	// In those cases, the computed value can be trusted to be border-box.
6803
	if ( ( !support.boxSizingReliable() && isBorderBox ||
6804

6805
		// Support: IE 10 - 11+, Edge 15 - 18+
6806
		// IE/Edge misreport `getComputedStyle` of table rows with width/height
6807
		// set in CSS while `offset*` properties report correct values.
6808
		// Interestingly, in some cases IE 9 doesn't suffer from this issue.
6809
		!support.reliableTrDimensions() && nodeName( elem, "tr" ) ||
6810

6811
		// Fall back to offsetWidth/offsetHeight when value is "auto"
6812
		// This happens for inline elements with no explicit setting (gh-3571)
6813
		val === "auto" ||
6814

6815
		// Support: Android <=4.1 - 4.3 only
6816
		// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
6817
		!parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) &&
6818

6819
		// Make sure the element is visible & connected
6820
		elem.getClientRects().length ) {
6821

6822
		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
6823

6824
		// Where available, offsetWidth/offsetHeight approximate border box dimensions.
6825
		// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the
6826
		// retrieved value as a content box dimension.
6827
		valueIsBorderBox = offsetProp in elem;
6828
		if ( valueIsBorderBox ) {
6829
			val = elem[ offsetProp ];
6830
		}
6831
	}
6832

6833
	// Normalize "" and auto
6834
	val = parseFloat( val ) || 0;
6835

6836
	// Adjust for the element's box model
6837
	return ( val +
6838
		boxModelAdjustment(
6839
			elem,
6840
			dimension,
6841
			extra || ( isBorderBox ? "border" : "content" ),
6842
			valueIsBorderBox,
6843
			styles,
6844

6845
			// Provide the current computed size to request scroll gutter calculation (gh-3589)
6846
			val
6847
		)
6848
	) + "px";
6849
}
6850

6851
jQuery.extend( {
6852

6853
	// Add in style property hooks for overriding the default
6854
	// behavior of getting and setting a style property
6855
	cssHooks: {
6856
		opacity: {
6857
			get: function( elem, computed ) {
6858
				if ( computed ) {
6859

6860
					// We should always get a number back from opacity
6861
					var ret = curCSS( elem, "opacity" );
6862
					return ret === "" ? "1" : ret;
6863
				}
6864
			}
6865
		}
6866
	},
6867

6868
	// Don't automatically add "px" to these possibly-unitless properties
6869
	cssNumber: {
6870
		"animationIterationCount": true,
6871
		"columnCount": true,
6872
		"fillOpacity": true,
6873
		"flexGrow": true,
6874
		"flexShrink": true,
6875
		"fontWeight": true,
6876
		"gridArea": true,
6877
		"gridColumn": true,
6878
		"gridColumnEnd": true,
6879
		"gridColumnStart": true,
6880
		"gridRow": true,
6881
		"gridRowEnd": true,
6882
		"gridRowStart": true,
6883
		"lineHeight": true,
6884
		"opacity": true,
6885
		"order": true,
6886
		"orphans": true,
6887
		"widows": true,
6888
		"zIndex": true,
6889
		"zoom": true
6890
	},
6891

6892
	// Add in properties whose names you wish to fix before
6893
	// setting or getting the value
6894
	cssProps: {},
6895

6896
	// Get and set the style property on a DOM Node
6897
	style: function( elem, name, value, extra ) {
6898

6899
		// Don't set styles on text and comment nodes
6900
		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
6901
			return;
6902
		}
6903

6904
		// Make sure that we're working with the right name
6905
		var ret, type, hooks,
6906
			origName = camelCase( name ),
6907
			isCustomProp = rcustomProp.test( name ),
6908
			style = elem.style;
6909

6910
		// Make sure that we're working with the right name. We don't
6911
		// want to query the value if it is a CSS custom property
6912
		// since they are user-defined.
6913
		if ( !isCustomProp ) {
6914
			name = finalPropName( origName );
6915
		}
6916

6917
		// Gets hook for the prefixed version, then unprefixed version
6918
		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6919

6920
		// Check if we're setting a value
6921
		if ( value !== undefined ) {
6922
			type = typeof value;
6923

6924
			// Convert "+=" or "-=" to relative numbers (#7345)
6925
			if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
6926
				value = adjustCSS( elem, name, ret );
6927

6928
				// Fixes bug #9237
6929
				type = "number";
6930
			}
6931

6932
			// Make sure that null and NaN values aren't set (#7116)
6933
			if ( value == null || value !== value ) {
6934
				return;
6935
			}
6936

6937
			// If a number was passed in, add the unit (except for certain CSS properties)
6938
			// The isCustomProp check can be removed in jQuery 4.0 when we only auto-append
6939
			// "px" to a few hardcoded values.
6940
			if ( type === "number" && !isCustomProp ) {
6941
				value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
6942
			}
6943

6944
			// background-* props affect original clone's values
6945
			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
6946
				style[ name ] = "inherit";
6947
			}
6948

6949
			// If a hook was provided, use that value, otherwise just set the specified value
6950
			if ( !hooks || !( "set" in hooks ) ||
6951
				( value = hooks.set( elem, value, extra ) ) !== undefined ) {
6952

6953
				if ( isCustomProp ) {
6954
					style.setProperty( name, value );
6955
				} else {
6956
					style[ name ] = value;
6957
				}
6958
			}
6959

6960
		} else {
6961

6962
			// If a hook was provided get the non-computed value from there
6963
			if ( hooks && "get" in hooks &&
6964
				( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
6965

6966
				return ret;
6967
			}
6968

6969
			// Otherwise just get the value from the style object
6970
			return style[ name ];
6971
		}
6972
	},
6973

6974
	css: function( elem, name, extra, styles ) {
6975
		var val, num, hooks,
6976
			origName = camelCase( name ),
6977
			isCustomProp = rcustomProp.test( name );
6978

6979
		// Make sure that we're working with the right name. We don't
6980
		// want to modify the value if it is a CSS custom property
6981
		// since they are user-defined.
6982
		if ( !isCustomProp ) {
6983
			name = finalPropName( origName );
6984
		}
6985

6986
		// Try prefixed name followed by the unprefixed name
6987
		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6988

6989
		// If a hook was provided get the computed value from there
6990
		if ( hooks && "get" in hooks ) {
6991
			val = hooks.get( elem, true, extra );
6992
		}
6993

6994
		// Otherwise, if a way to get the computed value exists, use that
6995
		if ( val === undefined ) {
6996
			val = curCSS( elem, name, styles );
6997
		}
6998

6999
		// Convert "normal" to computed value
7000
		if ( val === "normal" && name in cssNormalTransform ) {
7001
			val = cssNormalTransform[ name ];
7002
		}
7003

7004
		// Make numeric if forced or a qualifier was provided and val looks numeric
7005
		if ( extra === "" || extra ) {
7006
			num = parseFloat( val );
7007
			return extra === true || isFinite( num ) ? num || 0 : val;
7008
		}
7009

7010
		return val;
7011
	}
7012
} );
7013

7014
jQuery.each( [ "height", "width" ], function( _i, dimension ) {
7015
	jQuery.cssHooks[ dimension ] = {
7016
		get: function( elem, computed, extra ) {
7017
			if ( computed ) {
7018

7019
				// Certain elements can have dimension info if we invisibly show them
7020
				// but it must have a current display style that would benefit
7021
				return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
7022

7023
					// Support: Safari 8+
7024
					// Table columns in Safari have non-zero offsetWidth & zero
7025
					// getBoundingClientRect().width unless display is changed.
7026
					// Support: IE <=11 only
7027
					// Running getBoundingClientRect on a disconnected node
7028
					// in IE throws an error.
7029
					( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
7030
					swap( elem, cssShow, function() {
7031
						return getWidthOrHeight( elem, dimension, extra );
7032
					} ) :
7033
					getWidthOrHeight( elem, dimension, extra );
7034
			}
7035
		},
7036

7037
		set: function( elem, value, extra ) {
7038
			var matches,
7039
				styles = getStyles( elem ),
7040

7041
				// Only read styles.position if the test has a chance to fail
7042
				// to avoid forcing a reflow.
7043
				scrollboxSizeBuggy = !support.scrollboxSize() &&
7044
					styles.position === "absolute",
7045

7046
				// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)
7047
				boxSizingNeeded = scrollboxSizeBuggy || extra,
7048
				isBorderBox = boxSizingNeeded &&
7049
					jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
7050
				subtract = extra ?
7051
					boxModelAdjustment(
7052
						elem,
7053
						dimension,
7054
						extra,
7055
						isBorderBox,
7056
						styles
7057
					) :
7058
					0;
7059

7060
			// Account for unreliable border-box dimensions by comparing offset* to computed and
7061
			// faking a content-box to get border and padding (gh-3699)
7062
			if ( isBorderBox && scrollboxSizeBuggy ) {
7063
				subtract -= Math.ceil(
7064
					elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
7065
					parseFloat( styles[ dimension ] ) -
7066
					boxModelAdjustment( elem, dimension, "border", false, styles ) -
7067
					0.5
7068
				);
7069
			}
7070

7071
			// Convert to pixels if value adjustment is needed
7072
			if ( subtract && ( matches = rcssNum.exec( value ) ) &&
7073
				( matches[ 3 ] || "px" ) !== "px" ) {
7074

7075
				elem.style[ dimension ] = value;
7076
				value = jQuery.css( elem, dimension );
7077
			}
7078

7079
			return setPositiveNumber( elem, value, subtract );
7080
		}
7081
	};
7082
} );
7083

7084
jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
7085
	function( elem, computed ) {
7086
		if ( computed ) {
7087
			return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
7088
				elem.getBoundingClientRect().left -
7089
					swap( elem, { marginLeft: 0 }, function() {
7090
						return elem.getBoundingClientRect().left;
7091
					} )
7092
			) + "px";
7093
		}
7094
	}
7095
);
7096

7097
// These hooks are used by animate to expand properties
7098
jQuery.each( {
7099
	margin: "",
7100
	padding: "",
7101
	border: "Width"
7102
}, function( prefix, suffix ) {
7103
	jQuery.cssHooks[ prefix + suffix ] = {
7104
		expand: function( value ) {
7105
			var i = 0,
7106
				expanded = {},
7107

7108
				// Assumes a single number if not a string
7109
				parts = typeof value === "string" ? value.split( " " ) : [ value ];
7110

7111
			for ( ; i < 4; i++ ) {
7112
				expanded[ prefix + cssExpand[ i ] + suffix ] =
7113
					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
7114
			}
7115

7116
			return expanded;
7117
		}
7118
	};
7119

7120
	if ( prefix !== "margin" ) {
7121
		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
7122
	}
7123
} );
7124

7125
jQuery.fn.extend( {
7126
	css: function( name, value ) {
7127
		return access( this, function( elem, name, value ) {
7128
			var styles, len,
7129
				map = {},
7130
				i = 0;
7131

7132
			if ( Array.isArray( name ) ) {
7133
				styles = getStyles( elem );
7134
				len = name.length;
7135

7136
				for ( ; i < len; i++ ) {
7137
					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
7138
				}
7139

7140
				return map;
7141
			}
7142

7143
			return value !== undefined ?
7144
				jQuery.style( elem, name, value ) :
7145
				jQuery.css( elem, name );
7146
		}, name, value, arguments.length > 1 );
7147
	}
7148
} );
7149

7150

7151
// Based off of the plugin by Clint Helfers, with permission.
7152
// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
7153
jQuery.fn.delay = function( time, type ) {
7154
	time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
7155
	type = type || "fx";
7156

7157
	return this.queue( type, function( next, hooks ) {
7158
		var timeout = window.setTimeout( next, time );
7159
		hooks.stop = function() {
7160
			window.clearTimeout( timeout );
7161
		};
7162
	} );
7163
};
7164

7165

7166
( function() {
7167
	var input = document.createElement( "input" ),
7168
		select = document.createElement( "select" ),
7169
		opt = select.appendChild( document.createElement( "option" ) );
7170

7171
	input.type = "checkbox";
7172

7173
	// Support: Android <=4.3 only
7174
	// Default value for a checkbox should be "on"
7175
	support.checkOn = input.value !== "";
7176

7177
	// Support: IE <=11 only
7178
	// Must access selectedIndex to make default options select
7179
	support.optSelected = opt.selected;
7180

7181
	// Support: IE <=11 only
7182
	// An input loses its value after becoming a radio
7183
	input = document.createElement( "input" );
7184
	input.value = "t";
7185
	input.type = "radio";
7186
	support.radioValue = input.value === "t";
7187
} )();
7188

7189

7190
var boolHook,
7191
	attrHandle = jQuery.expr.attrHandle;
7192

7193
jQuery.fn.extend( {
7194
	attr: function( name, value ) {
7195
		return access( this, jQuery.attr, name, value, arguments.length > 1 );
7196
	},
7197

7198
	removeAttr: function( name ) {
7199
		return this.each( function() {
7200
			jQuery.removeAttr( this, name );
7201
		} );
7202
	}
7203
} );
7204

7205
jQuery.extend( {
7206
	attr: function( elem, name, value ) {
7207
		var ret, hooks,
7208
			nType = elem.nodeType;
7209

7210
		// Don't get/set attributes on text, comment and attribute nodes
7211
		if ( nType === 3 || nType === 8 || nType === 2 ) {
7212
			return;
7213
		}
7214

7215
		// Fallback to prop when attributes are not supported
7216
		if ( typeof elem.getAttribute === "undefined" ) {
7217
			return jQuery.prop( elem, name, value );
7218
		}
7219

7220
		// Attribute hooks are determined by the lowercase version
7221
		// Grab necessary hook if one is defined
7222
		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
7223
			hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
7224
				( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
7225
		}
7226

7227
		if ( value !== undefined ) {
7228
			if ( value === null ) {
7229
				jQuery.removeAttr( elem, name );
7230
				return;
7231
			}
7232

7233
			if ( hooks && "set" in hooks &&
7234
				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
7235
				return ret;
7236
			}
7237

7238
			elem.setAttribute( name, value + "" );
7239
			return value;
7240
		}
7241

7242
		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
7243
			return ret;
7244
		}
7245

7246
		ret = jQuery.find.attr( elem, name );
7247

7248
		// Non-existent attributes return null, we normalize to undefined
7249
		return ret == null ? undefined : ret;
7250
	},
7251

7252
	attrHooks: {
7253
		type: {
7254
			set: function( elem, value ) {
7255
				if ( !support.radioValue && value === "radio" &&
7256
					nodeName( elem, "input" ) ) {
7257
					var val = elem.value;
7258
					elem.setAttribute( "type", value );
7259
					if ( val ) {
7260
						elem.value = val;
7261
					}
7262
					return value;
7263
				}
7264
			}
7265
		}
7266
	},
7267

7268
	removeAttr: function( elem, value ) {
7269
		var name,
7270
			i = 0,
7271

7272
			// Attribute names can contain non-HTML whitespace characters
7273
			// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
7274
			attrNames = value && value.match( rnothtmlwhite );
7275

7276
		if ( attrNames && elem.nodeType === 1 ) {
7277
			while ( ( name = attrNames[ i++ ] ) ) {
7278
				elem.removeAttribute( name );
7279
			}
7280
		}
7281
	}
7282
} );
7283

7284
// Hooks for boolean attributes
7285
boolHook = {
7286
	set: function( elem, value, name ) {
7287
		if ( value === false ) {
7288

7289
			// Remove boolean attributes when set to false
7290
			jQuery.removeAttr( elem, name );
7291
		} else {
7292
			elem.setAttribute( name, name );
7293
		}
7294
		return name;
7295
	}
7296
};
7297

7298
jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) {
7299
	var getter = attrHandle[ name ] || jQuery.find.attr;
7300

7301
	attrHandle[ name ] = function( elem, name, isXML ) {
7302
		var ret, handle,
7303
			lowercaseName = name.toLowerCase();
7304

7305
		if ( !isXML ) {
7306

7307
			// Avoid an infinite loop by temporarily removing this function from the getter
7308
			handle = attrHandle[ lowercaseName ];
7309
			attrHandle[ lowercaseName ] = ret;
7310
			ret = getter( elem, name, isXML ) != null ?
7311
				lowercaseName :
7312
				null;
7313
			attrHandle[ lowercaseName ] = handle;
7314
		}
7315
		return ret;
7316
	};
7317
} );
7318

7319

7320

7321

7322
var rfocusable = /^(?:input|select|textarea|button)$/i,
7323
	rclickable = /^(?:a|area)$/i;
7324

7325
jQuery.fn.extend( {
7326
	prop: function( name, value ) {
7327
		return access( this, jQuery.prop, name, value, arguments.length > 1 );
7328
	},
7329

7330
	removeProp: function( name ) {
7331
		return this.each( function() {
7332
			delete this[ jQuery.propFix[ name ] || name ];
7333
		} );
7334
	}
7335
} );
7336

7337
jQuery.extend( {
7338
	prop: function( elem, name, value ) {
7339
		var ret, hooks,
7340
			nType = elem.nodeType;
7341

7342
		// Don't get/set properties on text, comment and attribute nodes
7343
		if ( nType === 3 || nType === 8 || nType === 2 ) {
7344
			return;
7345
		}
7346

7347
		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
7348

7349
			// Fix name and attach hooks
7350
			name = jQuery.propFix[ name ] || name;
7351
			hooks = jQuery.propHooks[ name ];
7352
		}
7353

7354
		if ( value !== undefined ) {
7355
			if ( hooks && "set" in hooks &&
7356
				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
7357
				return ret;
7358
			}
7359

7360
			return ( elem[ name ] = value );
7361
		}
7362

7363
		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
7364
			return ret;
7365
		}
7366

7367
		return elem[ name ];
7368
	},
7369

7370
	propHooks: {
7371
		tabIndex: {
7372
			get: function( elem ) {
7373

7374
				// Support: IE <=9 - 11 only
7375
				// elem.tabIndex doesn't always return the
7376
				// correct value when it hasn't been explicitly set
7377
				// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
7378
				// Use proper attribute retrieval(#12072)
7379
				var tabindex = jQuery.find.attr( elem, "tabindex" );
7380

7381
				if ( tabindex ) {
7382
					return parseInt( tabindex, 10 );
7383
				}
7384

7385
				if (
7386
					rfocusable.test( elem.nodeName ) ||
7387
					rclickable.test( elem.nodeName ) &&
7388
					elem.href
7389
				) {
7390
					return 0;
7391
				}
7392

7393
				return -1;
7394
			}
7395
		}
7396
	},
7397

7398
	propFix: {
7399
		"for": "htmlFor",
7400
		"class": "className"
7401
	}
7402
} );
7403

7404
// Support: IE <=11 only
7405
// Accessing the selectedIndex property
7406
// forces the browser to respect setting selected
7407
// on the option
7408
// The getter ensures a default option is selected
7409
// when in an optgroup
7410
// eslint rule "no-unused-expressions" is disabled for this code
7411
// since it considers such accessions noop
7412
if ( !support.optSelected ) {
7413
	jQuery.propHooks.selected = {
7414
		get: function( elem ) {
7415

7416
			/* eslint no-unused-expressions: "off" */
7417

7418
			var parent = elem.parentNode;
7419
			if ( parent && parent.parentNode ) {
7420
				parent.parentNode.selectedIndex;
7421
			}
7422
			return null;
7423
		},
7424
		set: function( elem ) {
7425

7426
			/* eslint no-unused-expressions: "off" */
7427

7428
			var parent = elem.parentNode;
7429
			if ( parent ) {
7430
				parent.selectedIndex;
7431

7432
				if ( parent.parentNode ) {
7433
					parent.parentNode.selectedIndex;
7434
				}
7435
			}
7436
		}
7437
	};
7438
}
7439

7440
jQuery.each( [
7441
	"tabIndex",
7442
	"readOnly",
7443
	"maxLength",
7444
	"cellSpacing",
7445
	"cellPadding",
7446
	"rowSpan",
7447
	"colSpan",
7448
	"useMap",
7449
	"frameBorder",
7450
	"contentEditable"
7451
], function() {
7452
	jQuery.propFix[ this.toLowerCase() ] = this;
7453
} );
7454

7455

7456

7457

7458
	// Strip and collapse whitespace according to HTML spec
7459
	// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
7460
	function stripAndCollapse( value ) {
7461
		var tokens = value.match( rnothtmlwhite ) || [];
7462
		return tokens.join( " " );
7463
	}
7464

7465

7466
function getClass( elem ) {
7467
	return elem.getAttribute && elem.getAttribute( "class" ) || "";
7468
}
7469

7470
function classesToArray( value ) {
7471
	if ( Array.isArray( value ) ) {
7472
		return value;
7473
	}
7474
	if ( typeof value === "string" ) {
7475
		return value.match( rnothtmlwhite ) || [];
7476
	}
7477
	return [];
7478
}
7479

7480
jQuery.fn.extend( {
7481
	addClass: function( value ) {
7482
		var classes, elem, cur, curValue, clazz, j, finalValue,
7483
			i = 0;
7484

7485
		if ( isFunction( value ) ) {
7486
			return this.each( function( j ) {
7487
				jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
7488
			} );
7489
		}
7490

7491
		classes = classesToArray( value );
7492

7493
		if ( classes.length ) {
7494
			while ( ( elem = this[ i++ ] ) ) {
7495
				curValue = getClass( elem );
7496
				cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
7497

7498
				if ( cur ) {
7499
					j = 0;
7500
					while ( ( clazz = classes[ j++ ] ) ) {
7501
						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
7502
							cur += clazz + " ";
7503
						}
7504
					}
7505

7506
					// Only assign if different to avoid unneeded rendering.
7507
					finalValue = stripAndCollapse( cur );
7508
					if ( curValue !== finalValue ) {
7509
						elem.setAttribute( "class", finalValue );
7510
					}
7511
				}
7512
			}
7513
		}
7514

7515
		return this;
7516
	},
7517

7518
	removeClass: function( value ) {
7519
		var classes, elem, cur, curValue, clazz, j, finalValue,
7520
			i = 0;
7521

7522
		if ( isFunction( value ) ) {
7523
			return this.each( function( j ) {
7524
				jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
7525
			} );
7526
		}
7527

7528
		if ( !arguments.length ) {
7529
			return this.attr( "class", "" );
7530
		}
7531

7532
		classes = classesToArray( value );
7533

7534
		if ( classes.length ) {
7535
			while ( ( elem = this[ i++ ] ) ) {
7536
				curValue = getClass( elem );
7537

7538
				// This expression is here for better compressibility (see addClass)
7539
				cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
7540

7541
				if ( cur ) {
7542
					j = 0;
7543
					while ( ( clazz = classes[ j++ ] ) ) {
7544

7545
						// Remove *all* instances
7546
						while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
7547
							cur = cur.replace( " " + clazz + " ", " " );
7548
						}
7549
					}
7550

7551
					// Only assign if different to avoid unneeded rendering.
7552
					finalValue = stripAndCollapse( cur );
7553
					if ( curValue !== finalValue ) {
7554
						elem.setAttribute( "class", finalValue );
7555
					}
7556
				}
7557
			}
7558
		}
7559

7560
		return this;
7561
	},
7562

7563
	toggleClass: function( value, stateVal ) {
7564
		var type = typeof value,
7565
			isValidValue = type === "string" || Array.isArray( value );
7566

7567
		if ( typeof stateVal === "boolean" && isValidValue ) {
7568
			return stateVal ? this.addClass( value ) : this.removeClass( value );
7569
		}
7570

7571
		if ( isFunction( value ) ) {
7572
			return this.each( function( i ) {
7573
				jQuery( this ).toggleClass(
7574
					value.call( this, i, getClass( this ), stateVal ),
7575
					stateVal
7576
				);
7577
			} );
7578
		}
7579

7580
		return this.each( function() {
7581
			var className, i, self, classNames;
7582

7583
			if ( isValidValue ) {
7584

7585
				// Toggle individual class names
7586
				i = 0;
7587
				self = jQuery( this );
7588
				classNames = classesToArray( value );
7589

7590
				while ( ( className = classNames[ i++ ] ) ) {
7591

7592
					// Check each className given, space separated list
7593
					if ( self.hasClass( className ) ) {
7594
						self.removeClass( className );
7595
					} else {
7596
						self.addClass( className );
7597
					}
7598
				}
7599

7600
			// Toggle whole class name
7601
			} else if ( value === undefined || type === "boolean" ) {
7602
				className = getClass( this );
7603
				if ( className ) {
7604

7605
					// Store className if set
7606
					dataPriv.set( this, "__className__", className );
7607
				}
7608

7609
				// If the element has a class name or if we're passed `false`,
7610
				// then remove the whole classname (if there was one, the above saved it).
7611
				// Otherwise bring back whatever was previously saved (if anything),
7612
				// falling back to the empty string if nothing was stored.
7613
				if ( this.setAttribute ) {
7614
					this.setAttribute( "class",
7615
						className || value === false ?
7616
							"" :
7617
							dataPriv.get( this, "__className__" ) || ""
7618
					);
7619
				}
7620
			}
7621
		} );
7622
	},
7623

7624
	hasClass: function( selector ) {
7625
		var className, elem,
7626
			i = 0;
7627

7628
		className = " " + selector + " ";
7629
		while ( ( elem = this[ i++ ] ) ) {
7630
			if ( elem.nodeType === 1 &&
7631
				( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
7632
				return true;
7633
			}
7634
		}
7635

7636
		return false;
7637
	}
7638
} );
7639

7640

7641

7642

7643
var rreturn = /\r/g;
7644

7645
jQuery.fn.extend( {
7646
	val: function( value ) {
7647
		var hooks, ret, valueIsFunction,
7648
			elem = this[ 0 ];
7649

7650
		if ( !arguments.length ) {
7651
			if ( elem ) {
7652
				hooks = jQuery.valHooks[ elem.type ] ||
7653
					jQuery.valHooks[ elem.nodeName.toLowerCase() ];
7654

7655
				if ( hooks &&
7656
					"get" in hooks &&
7657
					( ret = hooks.get( elem, "value" ) ) !== undefined
7658
				) {
7659
					return ret;
7660
				}
7661

7662
				ret = elem.value;
7663

7664
				// Handle most common string cases
7665
				if ( typeof ret === "string" ) {
7666
					return ret.replace( rreturn, "" );
7667
				}
7668

7669
				// Handle cases where value is null/undef or number
7670
				return ret == null ? "" : ret;
7671
			}
7672

7673
			return;
7674
		}
7675

7676
		valueIsFunction = isFunction( value );
7677

7678
		return this.each( function( i ) {
7679
			var val;
7680

7681
			if ( this.nodeType !== 1 ) {
7682
				return;
7683
			}
7684

7685
			if ( valueIsFunction ) {
7686
				val = value.call( this, i, jQuery( this ).val() );
7687
			} else {
7688
				val = value;
7689
			}
7690

7691
			// Treat null/undefined as ""; convert numbers to string
7692
			if ( val == null ) {
7693
				val = "";
7694

7695
			} else if ( typeof val === "number" ) {
7696
				val += "";
7697

7698
			} else if ( Array.isArray( val ) ) {
7699
				val = jQuery.map( val, function( value ) {
7700
					return value == null ? "" : value + "";
7701
				} );
7702
			}
7703

7704
			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
7705

7706
			// If set returns undefined, fall back to normal setting
7707
			if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
7708
				this.value = val;
7709
			}
7710
		} );
7711
	}
7712
} );
7713

7714
jQuery.extend( {
7715
	valHooks: {
7716
		option: {
7717
			get: function( elem ) {
7718

7719
				var val = jQuery.find.attr( elem, "value" );
7720
				return val != null ?
7721
					val :
7722

7723
					// Support: IE <=10 - 11 only
7724
					// option.text throws exceptions (#14686, #14858)
7725
					// Strip and collapse whitespace
7726
					// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
7727
					stripAndCollapse( jQuery.text( elem ) );
7728
			}
7729
		},
7730
		select: {
7731
			get: function( elem ) {
7732
				var value, option, i,
7733
					options = elem.options,
7734
					index = elem.selectedIndex,
7735
					one = elem.type === "select-one",
7736
					values = one ? null : [],
7737
					max = one ? index + 1 : options.length;
7738

7739
				if ( index < 0 ) {
7740
					i = max;
7741

7742
				} else {
7743
					i = one ? index : 0;
7744
				}
7745

7746
				// Loop through all the selected options
7747
				for ( ; i < max; i++ ) {
7748
					option = options[ i ];
7749

7750
					// Support: IE <=9 only
7751
					// IE8-9 doesn't update selected after form reset (#2551)
7752
					if ( ( option.selected || i === index ) &&
7753

7754
							// Don't return options that are disabled or in a disabled optgroup
7755
							!option.disabled &&
7756
							( !option.parentNode.disabled ||
7757
								!nodeName( option.parentNode, "optgroup" ) ) ) {
7758

7759
						// Get the specific value for the option
7760
						value = jQuery( option ).val();
7761

7762
						// We don't need an array for one selects
7763
						if ( one ) {
7764
							return value;
7765
						}
7766

7767
						// Multi-Selects return an array
7768
						values.push( value );
7769
					}
7770
				}
7771

7772
				return values;
7773
			},
7774

7775
			set: function( elem, value ) {
7776
				var optionSet, option,
7777
					options = elem.options,
7778
					values = jQuery.makeArray( value ),
7779
					i = options.length;
7780

7781
				while ( i-- ) {
7782
					option = options[ i ];
7783

7784
					/* eslint-disable no-cond-assign */
7785

7786
					if ( option.selected =
7787
						jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
7788
					) {
7789
						optionSet = true;
7790
					}
7791

7792
					/* eslint-enable no-cond-assign */
7793
				}
7794

7795
				// Force browsers to behave consistently when non-matching value is set
7796
				if ( !optionSet ) {
7797
					elem.selectedIndex = -1;
7798
				}
7799
				return values;
7800
			}
7801
		}
7802
	}
7803
} );
7804

7805
// Radios and checkboxes getter/setter
7806
jQuery.each( [ "radio", "checkbox" ], function() {
7807
	jQuery.valHooks[ this ] = {
7808
		set: function( elem, value ) {
7809
			if ( Array.isArray( value ) ) {
7810
				return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
7811
			}
7812
		}
7813
	};
7814
	if ( !support.checkOn ) {
7815
		jQuery.valHooks[ this ].get = function( elem ) {
7816
			return elem.getAttribute( "value" ) === null ? "on" : elem.value;
7817
		};
7818
	}
7819
} );
7820

7821

7822

7823

7824
// Return jQuery for attributes-only inclusion
7825

7826

7827
support.focusin = "onfocusin" in window;
7828

7829

7830
var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
7831
	stopPropagationCallback = function( e ) {
7832
		e.stopPropagation();
7833
	};
7834

7835
jQuery.extend( jQuery.event, {
7836

7837
	trigger: function( event, data, elem, onlyHandlers ) {
7838

7839
		var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,
7840
			eventPath = [ elem || document ],
7841
			type = hasOwn.call( event, "type" ) ? event.type : event,
7842
			namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
7843

7844
		cur = lastElement = tmp = elem = elem || document;
7845

7846
		// Don't do events on text and comment nodes
7847
		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
7848
			return;
7849
		}
7850

7851
		// focus/blur morphs to focusin/out; ensure we're not firing them right now
7852
		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
7853
			return;
7854
		}
7855

7856
		if ( type.indexOf( "." ) > -1 ) {
7857

7858
			// Namespaced trigger; create a regexp to match event type in handle()
7859
			namespaces = type.split( "." );
7860
			type = namespaces.shift();
7861
			namespaces.sort();
7862
		}
7863
		ontype = type.indexOf( ":" ) < 0 && "on" + type;
7864

7865
		// Caller can pass in a jQuery.Event object, Object, or just an event type string
7866
		event = event[ jQuery.expando ] ?
7867
			event :
7868
			new jQuery.Event( type, typeof event === "object" && event );
7869

7870
		// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
7871
		event.isTrigger = onlyHandlers ? 2 : 3;
7872
		event.namespace = namespaces.join( "." );
7873
		event.rnamespace = event.namespace ?
7874
			new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
7875
			null;
7876

7877
		// Clean up the event in case it is being reused
7878
		event.result = undefined;
7879
		if ( !event.target ) {
7880
			event.target = elem;
7881
		}
7882

7883
		// Clone any incoming data and prepend the event, creating the handler arg list
7884
		data = data == null ?
7885
			[ event ] :
7886
			jQuery.makeArray( data, [ event ] );
7887

7888
		// Allow special events to draw outside the lines
7889
		special = jQuery.event.special[ type ] || {};
7890
		if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
7891
			return;
7892
		}
7893

7894
		// Determine event propagation path in advance, per W3C events spec (#9951)
7895
		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
7896
		if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {
7897

7898
			bubbleType = special.delegateType || type;
7899
			if ( !rfocusMorph.test( bubbleType + type ) ) {
7900
				cur = cur.parentNode;
7901
			}
7902
			for ( ; cur; cur = cur.parentNode ) {
7903
				eventPath.push( cur );
7904
				tmp = cur;
7905
			}
7906

7907
			// Only add window if we got to document (e.g., not plain obj or detached DOM)
7908
			if ( tmp === ( elem.ownerDocument || document ) ) {
7909
				eventPath.push( tmp.defaultView || tmp.parentWindow || window );
7910
			}
7911
		}
7912

7913
		// Fire handlers on the event path
7914
		i = 0;
7915
		while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
7916
			lastElement = cur;
7917
			event.type = i > 1 ?
7918
				bubbleType :
7919
				special.bindType || type;
7920

7921
			// jQuery handler
7922
			handle = ( dataPriv.get( cur, "events" ) || Object.create( null ) )[ event.type ] &&
7923
				dataPriv.get( cur, "handle" );
7924
			if ( handle ) {
7925
				handle.apply( cur, data );
7926
			}
7927

7928
			// Native handler
7929
			handle = ontype && cur[ ontype ];
7930
			if ( handle && handle.apply && acceptData( cur ) ) {
7931
				event.result = handle.apply( cur, data );
7932
				if ( event.result === false ) {
7933
					event.preventDefault();
7934
				}
7935
			}
7936
		}
7937
		event.type = type;
7938

7939
		// If nobody prevented the default action, do it now
7940
		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
7941

7942
			if ( ( !special._default ||
7943
				special._default.apply( eventPath.pop(), data ) === false ) &&
7944
				acceptData( elem ) ) {
7945

7946
				// Call a native DOM method on the target with the same name as the event.
7947
				// Don't do default actions on window, that's where global variables be (#6170)
7948
				if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {
7949

7950
					// Don't re-trigger an onFOO event when we call its FOO() method
7951
					tmp = elem[ ontype ];
7952

7953
					if ( tmp ) {
7954
						elem[ ontype ] = null;
7955
					}
7956

7957
					// Prevent re-triggering of the same event, since we already bubbled it above
7958
					jQuery.event.triggered = type;
7959

7960
					if ( event.isPropagationStopped() ) {
7961
						lastElement.addEventListener( type, stopPropagationCallback );
7962
					}
7963

7964
					elem[ type ]();
7965

7966
					if ( event.isPropagationStopped() ) {
7967
						lastElement.removeEventListener( type, stopPropagationCallback );
7968
					}
7969

7970
					jQuery.event.triggered = undefined;
7971

7972
					if ( tmp ) {
7973
						elem[ ontype ] = tmp;
7974
					}
7975
				}
7976
			}
7977
		}
7978

7979
		return event.result;
7980
	},
7981

7982
	// Piggyback on a donor event to simulate a different one
7983
	// Used only for `focus(in | out)` events
7984
	simulate: function( type, elem, event ) {
7985
		var e = jQuery.extend(
7986
			new jQuery.Event(),
7987
			event,
7988
			{
7989
				type: type,
7990
				isSimulated: true
7991
			}
7992
		);
7993

7994
		jQuery.event.trigger( e, null, elem );
7995
	}
7996

7997
} );
7998

7999
jQuery.fn.extend( {
8000

8001
	trigger: function( type, data ) {
8002
		return this.each( function() {
8003
			jQuery.event.trigger( type, data, this );
8004
		} );
8005
	},
8006
	triggerHandler: function( type, data ) {
8007
		var elem = this[ 0 ];
8008
		if ( elem ) {
8009
			return jQuery.event.trigger( type, data, elem, true );
8010
		}
8011
	}
8012
} );
8013

8014

8015
// Support: Firefox <=44
8016
// Firefox doesn't have focus(in | out) events
8017
// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
8018
//
8019
// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
8020
// focus(in | out) events fire after focus & blur events,
8021
// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
8022
// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
8023
if ( !support.focusin ) {
8024
	jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
8025

8026
		// Attach a single capturing handler on the document while someone wants focusin/focusout
8027
		var handler = function( event ) {
8028
			jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
8029
		};
8030

8031
		jQuery.event.special[ fix ] = {
8032
			setup: function() {
8033

8034
				// Handle: regular nodes (via `this.ownerDocument`), window
8035
				// (via `this.document`) & document (via `this`).
8036
				var doc = this.ownerDocument || this.document || this,
8037
					attaches = dataPriv.access( doc, fix );
8038

8039
				if ( !attaches ) {
8040
					doc.addEventListener( orig, handler, true );
8041
				}
8042
				dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
8043
			},
8044
			teardown: function() {
8045
				var doc = this.ownerDocument || this.document || this,
8046
					attaches = dataPriv.access( doc, fix ) - 1;
8047

8048
				if ( !attaches ) {
8049
					doc.removeEventListener( orig, handler, true );
8050
					dataPriv.remove( doc, fix );
8051

8052
				} else {
8053
					dataPriv.access( doc, fix, attaches );
8054
				}
8055
			}
8056
		};
8057
	} );
8058
}
8059

8060

8061
// Cross-browser xml parsing
8062
jQuery.parseXML = function( data ) {
8063
	var xml, parserErrorElem;
8064
	if ( !data || typeof data !== "string" ) {
8065
		return null;
8066
	}
8067

8068
	// Support: IE 9 - 11 only
8069
	// IE throws on parseFromString with invalid input.
8070
	try {
8071
		xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
8072
	} catch ( e ) {}
8073

8074
	parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ];
8075
	if ( !xml || parserErrorElem ) {
8076
		jQuery.error( "Invalid XML: " + (
8077
			parserErrorElem ?
8078
				jQuery.map( parserErrorElem.childNodes, function( el ) {
8079
					return el.textContent;
8080
				} ).join( "\n" ) :
8081
				data
8082
		) );
8083
	}
8084
	return xml;
8085
};
8086

8087

8088
var
8089
	rbracket = /\[\]$/,
8090
	rCRLF = /\r?\n/g,
8091
	rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
8092
	rsubmittable = /^(?:input|select|textarea|keygen)/i;
8093

8094
function buildParams( prefix, obj, traditional, add ) {
8095
	var name;
8096

8097
	if ( Array.isArray( obj ) ) {
8098

8099
		// Serialize array item.
8100
		jQuery.each( obj, function( i, v ) {
8101
			if ( traditional || rbracket.test( prefix ) ) {
8102

8103
				// Treat each array item as a scalar.
8104
				add( prefix, v );
8105

8106
			} else {
8107

8108
				// Item is non-scalar (array or object), encode its numeric index.
8109
				buildParams(
8110
					prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
8111
					v,
8112
					traditional,
8113
					add
8114
				);
8115
			}
8116
		} );
8117

8118
	} else if ( !traditional && toType( obj ) === "object" ) {
8119

8120
		// Serialize object item.
8121
		for ( name in obj ) {
8122
			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
8123
		}
8124

8125
	} else {
8126

8127
		// Serialize scalar item.
8128
		add( prefix, obj );
8129
	}
8130
}
8131

8132
// Serialize an array of form elements or a set of
8133
// key/values into a query string
8134
jQuery.param = function( a, traditional ) {
8135
	var prefix,
8136
		s = [],
8137
		add = function( key, valueOrFunction ) {
8138

8139
			// If value is a function, invoke it and use its return value
8140
			var value = isFunction( valueOrFunction ) ?
8141
				valueOrFunction() :
8142
				valueOrFunction;
8143

8144
			s[ s.length ] = encodeURIComponent( key ) + "=" +
8145
				encodeURIComponent( value == null ? "" : value );
8146
		};
8147

8148
	if ( a == null ) {
8149
		return "";
8150
	}
8151

8152
	// If an array was passed in, assume that it is an array of form elements.
8153
	if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
8154

8155
		// Serialize the form elements
8156
		jQuery.each( a, function() {
8157
			add( this.name, this.value );
8158
		} );
8159

8160
	} else {
8161

8162
		// If traditional, encode the "old" way (the way 1.3.2 or older
8163
		// did it), otherwise encode params recursively.
8164
		for ( prefix in a ) {
8165
			buildParams( prefix, a[ prefix ], traditional, add );
8166
		}
8167
	}
8168

8169
	// Return the resulting serialization
8170
	return s.join( "&" );
8171
};
8172

8173
jQuery.fn.extend( {
8174
	serialize: function() {
8175
		return jQuery.param( this.serializeArray() );
8176
	},
8177
	serializeArray: function() {
8178
		return this.map( function() {
8179

8180
			// Can add propHook for "elements" to filter or add form elements
8181
			var elements = jQuery.prop( this, "elements" );
8182
			return elements ? jQuery.makeArray( elements ) : this;
8183
		} ).filter( function() {
8184
			var type = this.type;
8185

8186
			// Use .is( ":disabled" ) so that fieldset[disabled] works
8187
			return this.name && !jQuery( this ).is( ":disabled" ) &&
8188
				rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
8189
				( this.checked || !rcheckableType.test( type ) );
8190
		} ).map( function( _i, elem ) {
8191
			var val = jQuery( this ).val();
8192

8193
			if ( val == null ) {
8194
				return null;
8195
			}
8196

8197
			if ( Array.isArray( val ) ) {
8198
				return jQuery.map( val, function( val ) {
8199
					return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
8200
				} );
8201
			}
8202

8203
			return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
8204
		} ).get();
8205
	}
8206
} );
8207

8208

8209
jQuery.fn.extend( {
8210
	wrapAll: function( html ) {
8211
		var wrap;
8212

8213
		if ( this[ 0 ] ) {
8214
			if ( isFunction( html ) ) {
8215
				html = html.call( this[ 0 ] );
8216
			}
8217

8218
			// The elements to wrap the target around
8219
			wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
8220

8221
			if ( this[ 0 ].parentNode ) {
8222
				wrap.insertBefore( this[ 0 ] );
8223
			}
8224

8225
			wrap.map( function() {
8226
				var elem = this;
8227

8228
				while ( elem.firstElementChild ) {
8229
					elem = elem.firstElementChild;
8230
				}
8231

8232
				return elem;
8233
			} ).append( this );
8234
		}
8235

8236
		return this;
8237
	},
8238

8239
	wrapInner: function( html ) {
8240
		if ( isFunction( html ) ) {
8241
			return this.each( function( i ) {
8242
				jQuery( this ).wrapInner( html.call( this, i ) );
8243
			} );
8244
		}
8245

8246
		return this.each( function() {
8247
			var self = jQuery( this ),
8248
				contents = self.contents();
8249

8250
			if ( contents.length ) {
8251
				contents.wrapAll( html );
8252

8253
			} else {
8254
				self.append( html );
8255
			}
8256
		} );
8257
	},
8258

8259
	wrap: function( html ) {
8260
		var htmlIsFunction = isFunction( html );
8261

8262
		return this.each( function( i ) {
8263
			jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );
8264
		} );
8265
	},
8266

8267
	unwrap: function( selector ) {
8268
		this.parent( selector ).not( "body" ).each( function() {
8269
			jQuery( this ).replaceWith( this.childNodes );
8270
		} );
8271
		return this;
8272
	}
8273
} );
8274

8275

8276
jQuery.expr.pseudos.hidden = function( elem ) {
8277
	return !jQuery.expr.pseudos.visible( elem );
8278
};
8279
jQuery.expr.pseudos.visible = function( elem ) {
8280
	return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
8281
};
8282

8283

8284

8285

8286
// Support: Safari 8 only
8287
// In Safari 8 documents created via document.implementation.createHTMLDocument
8288
// collapse sibling forms: the second one becomes a child of the first one.
8289
// Because of that, this security measure has to be disabled in Safari 8.
8290
// https://bugs.webkit.org/show_bug.cgi?id=137337
8291
support.createHTMLDocument = ( function() {
8292
	var body = document.implementation.createHTMLDocument( "" ).body;
8293
	body.innerHTML = "<form></form><form></form>";
8294
	return body.childNodes.length === 2;
8295
} )();
8296

8297

8298
// Argument "data" should be string of html
8299
// context (optional): If specified, the fragment will be created in this context,
8300
// defaults to document
8301
// keepScripts (optional): If true, will include scripts passed in the html string
8302
jQuery.parseHTML = function( data, context, keepScripts ) {
8303
	if ( typeof data !== "string" ) {
8304
		return [];
8305
	}
8306
	if ( typeof context === "boolean" ) {
8307
		keepScripts = context;
8308
		context = false;
8309
	}
8310

8311
	var base, parsed, scripts;
8312

8313
	if ( !context ) {
8314

8315
		// Stop scripts or inline event handlers from being executed immediately
8316
		// by using document.implementation
8317
		if ( support.createHTMLDocument ) {
8318
			context = document.implementation.createHTMLDocument( "" );
8319

8320
			// Set the base href for the created document
8321
			// so any parsed elements with URLs
8322
			// are based on the document's URL (gh-2965)
8323
			base = context.createElement( "base" );
8324
			base.href = document.location.href;
8325
			context.head.appendChild( base );
8326
		} else {
8327
			context = document;
8328
		}
8329
	}
8330

8331
	parsed = rsingleTag.exec( data );
8332
	scripts = !keepScripts && [];
8333

8334
	// Single tag
8335
	if ( parsed ) {
8336
		return [ context.createElement( parsed[ 1 ] ) ];
8337
	}
8338

8339
	parsed = buildFragment( [ data ], context, scripts );
8340

8341
	if ( scripts && scripts.length ) {
8342
		jQuery( scripts ).remove();
8343
	}
8344

8345
	return jQuery.merge( [], parsed.childNodes );
8346
};
8347

8348

8349
jQuery.offset = {
8350
	setOffset: function( elem, options, i ) {
8351
		var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
8352
			position = jQuery.css( elem, "position" ),
8353
			curElem = jQuery( elem ),
8354
			props = {};
8355

8356
		// Set position first, in-case top/left are set even on static elem
8357
		if ( position === "static" ) {
8358
			elem.style.position = "relative";
8359
		}
8360

8361
		curOffset = curElem.offset();
8362
		curCSSTop = jQuery.css( elem, "top" );
8363
		curCSSLeft = jQuery.css( elem, "left" );
8364
		calculatePosition = ( position === "absolute" || position === "fixed" ) &&
8365
			( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;
8366

8367
		// Need to be able to calculate position if either
8368
		// top or left is auto and position is either absolute or fixed
8369
		if ( calculatePosition ) {
8370
			curPosition = curElem.position();
8371
			curTop = curPosition.top;
8372
			curLeft = curPosition.left;
8373

8374
		} else {
8375
			curTop = parseFloat( curCSSTop ) || 0;
8376
			curLeft = parseFloat( curCSSLeft ) || 0;
8377
		}
8378

8379
		if ( isFunction( options ) ) {
8380

8381
			// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
8382
			options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
8383
		}
8384

8385
		if ( options.top != null ) {
8386
			props.top = ( options.top - curOffset.top ) + curTop;
8387
		}
8388
		if ( options.left != null ) {
8389
			props.left = ( options.left - curOffset.left ) + curLeft;
8390
		}
8391

8392
		if ( "using" in options ) {
8393
			options.using.call( elem, props );
8394

8395
		} else {
8396
			curElem.css( props );
8397
		}
8398
	}
8399
};
8400

8401
jQuery.fn.extend( {
8402

8403
	// offset() relates an element's border box to the document origin
8404
	offset: function( options ) {
8405

8406
		// Preserve chaining for setter
8407
		if ( arguments.length ) {
8408
			return options === undefined ?
8409
				this :
8410
				this.each( function( i ) {
8411
					jQuery.offset.setOffset( this, options, i );
8412
				} );
8413
		}
8414

8415
		var rect, win,
8416
			elem = this[ 0 ];
8417

8418
		if ( !elem ) {
8419
			return;
8420
		}
8421

8422
		// Return zeros for disconnected and hidden (display: none) elements (gh-2310)
8423
		// Support: IE <=11 only
8424
		// Running getBoundingClientRect on a
8425
		// disconnected node in IE throws an error
8426
		if ( !elem.getClientRects().length ) {
8427
			return { top: 0, left: 0 };
8428
		}
8429

8430
		// Get document-relative position by adding viewport scroll to viewport-relative gBCR
8431
		rect = elem.getBoundingClientRect();
8432
		win = elem.ownerDocument.defaultView;
8433
		return {
8434
			top: rect.top + win.pageYOffset,
8435
			left: rect.left + win.pageXOffset
8436
		};
8437
	},
8438

8439
	// position() relates an element's margin box to its offset parent's padding box
8440
	// This corresponds to the behavior of CSS absolute positioning
8441
	position: function() {
8442
		if ( !this[ 0 ] ) {
8443
			return;
8444
		}
8445

8446
		var offsetParent, offset, doc,
8447
			elem = this[ 0 ],
8448
			parentOffset = { top: 0, left: 0 };
8449

8450
		// position:fixed elements are offset from the viewport, which itself always has zero offset
8451
		if ( jQuery.css( elem, "position" ) === "fixed" ) {
8452

8453
			// Assume position:fixed implies availability of getBoundingClientRect
8454
			offset = elem.getBoundingClientRect();
8455

8456
		} else {
8457
			offset = this.offset();
8458

8459
			// Account for the *real* offset parent, which can be the document or its root element
8460
			// when a statically positioned element is identified
8461
			doc = elem.ownerDocument;
8462
			offsetParent = elem.offsetParent || doc.documentElement;
8463
			while ( offsetParent &&
8464
				( offsetParent === doc.body || offsetParent === doc.documentElement ) &&
8465
				jQuery.css( offsetParent, "position" ) === "static" ) {
8466

8467
				offsetParent = offsetParent.parentNode;
8468
			}
8469
			if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {
8470

8471
				// Incorporate borders into its offset, since they are outside its content origin
8472
				parentOffset = jQuery( offsetParent ).offset();
8473
				parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true );
8474
				parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true );
8475
			}
8476
		}
8477

8478
		// Subtract parent offsets and element margins
8479
		return {
8480
			top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
8481
			left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
8482
		};
8483
	},
8484

8485
	// This method will return documentElement in the following cases:
8486
	// 1) For the element inside the iframe without offsetParent, this method will return
8487
	//    documentElement of the parent window
8488
	// 2) For the hidden or detached element
8489
	// 3) For body or html element, i.e. in case of the html node - it will return itself
8490
	//
8491
	// but those exceptions were never presented as a real life use-cases
8492
	// and might be considered as more preferable results.
8493
	//
8494
	// This logic, however, is not guaranteed and can change at any point in the future
8495
	offsetParent: function() {
8496
		return this.map( function() {
8497
			var offsetParent = this.offsetParent;
8498

8499
			while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
8500
				offsetParent = offsetParent.offsetParent;
8501
			}
8502

8503
			return offsetParent || documentElement;
8504
		} );
8505
	}
8506
} );
8507

8508
// Create scrollLeft and scrollTop methods
8509
jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
8510
	var top = "pageYOffset" === prop;
8511

8512
	jQuery.fn[ method ] = function( val ) {
8513
		return access( this, function( elem, method, val ) {
8514

8515
			// Coalesce documents and windows
8516
			var win;
8517
			if ( isWindow( elem ) ) {
8518
				win = elem;
8519
			} else if ( elem.nodeType === 9 ) {
8520
				win = elem.defaultView;
8521
			}
8522

8523
			if ( val === undefined ) {
8524
				return win ? win[ prop ] : elem[ method ];
8525
			}
8526

8527
			if ( win ) {
8528
				win.scrollTo(
8529
					!top ? val : win.pageXOffset,
8530
					top ? val : win.pageYOffset
8531
				);
8532

8533
			} else {
8534
				elem[ method ] = val;
8535
			}
8536
		}, method, val, arguments.length );
8537
	};
8538
} );
8539

8540
// Support: Safari <=7 - 9.1, Chrome <=37 - 49
8541
// Add the top/left cssHooks using jQuery.fn.position
8542
// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
8543
// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
8544
// getComputedStyle returns percent when specified for top/left/bottom/right;
8545
// rather than make the css module depend on the offset module, just check for it here
8546
jQuery.each( [ "top", "left" ], function( _i, prop ) {
8547
	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
8548
		function( elem, computed ) {
8549
			if ( computed ) {
8550
				computed = curCSS( elem, prop );
8551

8552
				// If curCSS returns percentage, fallback to offset
8553
				return rnumnonpx.test( computed ) ?
8554
					jQuery( elem ).position()[ prop ] + "px" :
8555
					computed;
8556
			}
8557
		}
8558
	);
8559
} );
8560

8561

8562
// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
8563
jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
8564
	jQuery.each( {
8565
		padding: "inner" + name,
8566
		content: type,
8567
		"": "outer" + name
8568
	}, function( defaultExtra, funcName ) {
8569

8570
		// Margin is only for outerHeight, outerWidth
8571
		jQuery.fn[ funcName ] = function( margin, value ) {
8572
			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
8573
				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
8574

8575
			return access( this, function( elem, type, value ) {
8576
				var doc;
8577

8578
				if ( isWindow( elem ) ) {
8579

8580
					// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
8581
					return funcName.indexOf( "outer" ) === 0 ?
8582
						elem[ "inner" + name ] :
8583
						elem.document.documentElement[ "client" + name ];
8584
				}
8585

8586
				// Get document width or height
8587
				if ( elem.nodeType === 9 ) {
8588
					doc = elem.documentElement;
8589

8590
					// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
8591
					// whichever is greatest
8592
					return Math.max(
8593
						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
8594
						elem.body[ "offset" + name ], doc[ "offset" + name ],
8595
						doc[ "client" + name ]
8596
					);
8597
				}
8598

8599
				return value === undefined ?
8600

8601
					// Get width or height on the element, requesting but not forcing parseFloat
8602
					jQuery.css( elem, type, extra ) :
8603

8604
					// Set width or height on the element
8605
					jQuery.style( elem, type, value, extra );
8606
			}, type, chainable ? margin : undefined, chainable );
8607
		};
8608
	} );
8609
} );
8610

8611

8612
jQuery.fn.extend( {
8613

8614
	bind: function( types, data, fn ) {
8615
		return this.on( types, null, data, fn );
8616
	},
8617
	unbind: function( types, fn ) {
8618
		return this.off( types, null, fn );
8619
	},
8620

8621
	delegate: function( selector, types, data, fn ) {
8622
		return this.on( types, selector, data, fn );
8623
	},
8624
	undelegate: function( selector, types, fn ) {
8625

8626
		// ( namespace ) or ( selector, types [, fn] )
8627
		return arguments.length === 1 ?
8628
			this.off( selector, "**" ) :
8629
			this.off( types, selector || "**", fn );
8630
	},
8631

8632
	hover: function( fnOver, fnOut ) {
8633
		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
8634
	}
8635
} );
8636

8637
jQuery.each(
8638
	( "blur focus focusin focusout resize scroll click dblclick " +
8639
	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
8640
	"change select submit keydown keypress keyup contextmenu" ).split( " " ),
8641
	function( _i, name ) {
8642

8643
		// Handle event binding
8644
		jQuery.fn[ name ] = function( data, fn ) {
8645
			return arguments.length > 0 ?
8646
				this.on( name, null, data, fn ) :
8647
				this.trigger( name );
8648
		};
8649
	}
8650
);
8651

8652

8653

8654

8655
// Support: Android <=4.0 only
8656
// Make sure we trim BOM and NBSP
8657
var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
8658

8659
// Bind a function to a context, optionally partially applying any
8660
// arguments.
8661
// jQuery.proxy is deprecated to promote standards (specifically Function#bind)
8662
// However, it is not slated for removal any time soon
8663
jQuery.proxy = function( fn, context ) {
8664
	var tmp, args, proxy;
8665

8666
	if ( typeof context === "string" ) {
8667
		tmp = fn[ context ];
8668
		context = fn;
8669
		fn = tmp;
8670
	}
8671

8672
	// Quick check to determine if target is callable, in the spec
8673
	// this throws a TypeError, but we will just return undefined.
8674
	if ( !isFunction( fn ) ) {
8675
		return undefined;
8676
	}
8677

8678
	// Simulated bind
8679
	args = slice.call( arguments, 2 );
8680
	proxy = function() {
8681
		return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
8682
	};
8683

8684
	// Set the guid of unique handler to the same of original handler, so it can be removed
8685
	proxy.guid = fn.guid = fn.guid || jQuery.guid++;
8686

8687
	return proxy;
8688
};
8689

8690
jQuery.holdReady = function( hold ) {
8691
	if ( hold ) {
8692
		jQuery.readyWait++;
8693
	} else {
8694
		jQuery.ready( true );
8695
	}
8696
};
8697
jQuery.isArray = Array.isArray;
8698
jQuery.parseJSON = JSON.parse;
8699
jQuery.nodeName = nodeName;
8700
jQuery.isFunction = isFunction;
8701
jQuery.isWindow = isWindow;
8702
jQuery.camelCase = camelCase;
8703
jQuery.type = toType;
8704

8705
jQuery.now = Date.now;
8706

8707
jQuery.isNumeric = function( obj ) {
8708

8709
	// As of jQuery 3.0, isNumeric is limited to
8710
	// strings and numbers (primitives or objects)
8711
	// that can be coerced to finite numbers (gh-2662)
8712
	var type = jQuery.type( obj );
8713
	return ( type === "number" || type === "string" ) &&
8714

8715
		// parseFloat NaNs numeric-cast false positives ("")
8716
		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
8717
		// subtraction forces infinities to NaN
8718
		!isNaN( obj - parseFloat( obj ) );
8719
};
8720

8721
jQuery.trim = function( text ) {
8722
	return text == null ?
8723
		"" :
8724
		( text + "" ).replace( rtrim, "" );
8725
};
8726

8727

8728

8729
// Register as a named AMD module, since jQuery can be concatenated with other
8730
// files that may use define, but not via a proper concatenation script that
8731
// understands anonymous AMD modules. A named AMD is safest and most robust
8732
// way to register. Lowercase jquery is used because AMD module names are
8733
// derived from file names, and jQuery is normally delivered in a lowercase
8734
// file name. Do this after creating the global so that if an AMD module wants
8735
// to call noConflict to hide this version of jQuery, it will work.
8736

8737
// Note that for maximum portability, libraries that are not jQuery should
8738
// declare themselves as anonymous modules, and avoid setting a global if an
8739
// AMD loader is present. jQuery is a special case. For more information, see
8740
// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
8741

8742
if ( typeof define === "function" && define.amd ) {
8743
	define( "jquery", [], function() {
8744
		return jQuery;
8745
	} );
8746
}
8747

8748

8749

8750

8751
var
8752

8753
	// Map over jQuery in case of overwrite
8754
	_jQuery = window.jQuery,
8755

8756
	// Map over the $ in case of overwrite
8757
	_$ = window.$;
8758

8759
jQuery.noConflict = function( deep ) {
8760
	if ( window.$ === jQuery ) {
8761
		window.$ = _$;
8762
	}
8763

8764
	if ( deep && window.jQuery === jQuery ) {
8765
		window.jQuery = _jQuery;
8766
	}
8767

8768
	return jQuery;
8769
};
8770

8771
// Expose jQuery and $ identifiers, even in AMD
8772
// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
8773
// and CommonJS for browser emulators (#13566)
8774
if ( typeof noGlobal === "undefined" ) {
8775
	window.jQuery = window.$ = jQuery;
8776
}
8777

8778

8779

8780

8781
return jQuery;
8782
} );
8783