View | Details | Raw Unified | Return to bug 15883
Collapse All | Expand All

(-)a/koha-tmpl/intranet-tmpl/lib/jquery/jquery-2.2.3.js (+9842 lines)
Line 0 Link Here
1
/*!
2
 * jQuery JavaScript Library v2.2.3
3
 * http://jquery.com/
4
 *
5
 * Includes Sizzle.js
6
 * http://sizzlejs.com/
7
 *
8
 * Copyright jQuery Foundation and other contributors
9
 * Released under the MIT license
10
 * http://jquery.org/license
11
 *
12
 * Date: 2016-04-05T19:26Z
13
 */
14
15
(function( global, factory ) {
16
17
	if ( typeof module === "object" && typeof module.exports === "object" ) {
18
		// For CommonJS and CommonJS-like environments where a proper `window`
19
		// is present, execute the factory and get jQuery.
20
		// For environments that do not have a `window` with a `document`
21
		// (such as Node.js), expose a factory as module.exports.
22
		// This accentuates the need for the creation of a real `window`.
23
		// e.g. var jQuery = require("jquery")(window);
24
		// See ticket #14549 for more info.
25
		module.exports = global.document ?
26
			factory( global, true ) :
27
			function( w ) {
28
				if ( !w.document ) {
29
					throw new Error( "jQuery requires a window with a document" );
30
				}
31
				return factory( w );
32
			};
33
	} else {
34
		factory( global );
35
	}
36
37
// Pass this if window is not defined yet
38
}(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
39
40
// Support: Firefox 18+
41
// Can't be in strict mode, several libs including ASP.NET trace
42
// the stack via arguments.caller.callee and Firefox dies if
43
// you try to trace through "use strict" call chains. (#13335)
44
//"use strict";
45
var arr = [];
46
47
var document = window.document;
48
49
var slice = arr.slice;
50
51
var concat = arr.concat;
52
53
var push = arr.push;
54
55
var indexOf = arr.indexOf;
56
57
var class2type = {};
58
59
var toString = class2type.toString;
60
61
var hasOwn = class2type.hasOwnProperty;
62
63
var support = {};
64
65
66
67
var
68
	version = "2.2.3",
69
70
	// Define a local copy of jQuery
71
	jQuery = function( selector, context ) {
72
73
		// The jQuery object is actually just the init constructor 'enhanced'
74
		// Need init if jQuery is called (just allow error to be thrown if not included)
75
		return new jQuery.fn.init( selector, context );
76
	},
77
78
	// Support: Android<4.1
79
	// Make sure we trim BOM and NBSP
80
	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
81
82
	// Matches dashed string for camelizing
83
	rmsPrefix = /^-ms-/,
84
	rdashAlpha = /-([\da-z])/gi,
85
86
	// Used by jQuery.camelCase as callback to replace()
87
	fcamelCase = function( all, letter ) {
88
		return letter.toUpperCase();
89
	};
90
91
jQuery.fn = jQuery.prototype = {
92
93
	// The current version of jQuery being used
94
	jquery: version,
95
96
	constructor: jQuery,
97
98
	// Start with an empty selector
99
	selector: "",
100
101
	// The default length of a jQuery object is 0
102
	length: 0,
103
104
	toArray: function() {
105
		return slice.call( this );
106
	},
107
108
	// Get the Nth element in the matched element set OR
109
	// Get the whole matched element set as a clean array
110
	get: function( num ) {
111
		return num != null ?
112
113
			// Return just the one element from the set
114
			( num < 0 ? this[ num + this.length ] : this[ num ] ) :
115
116
			// Return all the elements in a clean array
117
			slice.call( this );
118
	},
119
120
	// Take an array of elements and push it onto the stack
121
	// (returning the new matched element set)
122
	pushStack: function( elems ) {
123
124
		// Build a new jQuery matched element set
125
		var ret = jQuery.merge( this.constructor(), elems );
126
127
		// Add the old object onto the stack (as a reference)
128
		ret.prevObject = this;
129
		ret.context = this.context;
130
131
		// Return the newly-formed element set
132
		return ret;
133
	},
134
135
	// Execute a callback for every element in the matched set.
136
	each: function( callback ) {
137
		return jQuery.each( this, callback );
138
	},
139
140
	map: function( callback ) {
141
		return this.pushStack( jQuery.map( this, function( elem, i ) {
142
			return callback.call( elem, i, elem );
143
		} ) );
144
	},
145
146
	slice: function() {
147
		return this.pushStack( slice.apply( this, arguments ) );
148
	},
149
150
	first: function() {
151
		return this.eq( 0 );
152
	},
153
154
	last: function() {
155
		return this.eq( -1 );
156
	},
157
158
	eq: function( i ) {
159
		var len = this.length,
160
			j = +i + ( i < 0 ? len : 0 );
161
		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
162
	},
163
164
	end: function() {
165
		return this.prevObject || this.constructor();
166
	},
167
168
	// For internal use only.
169
	// Behaves like an Array's method, not like a jQuery method.
170
	push: push,
171
	sort: arr.sort,
172
	splice: arr.splice
173
};
174
175
jQuery.extend = jQuery.fn.extend = function() {
176
	var options, name, src, copy, copyIsArray, clone,
177
		target = arguments[ 0 ] || {},
178
		i = 1,
179
		length = arguments.length,
180
		deep = false;
181
182
	// Handle a deep copy situation
183
	if ( typeof target === "boolean" ) {
184
		deep = target;
185
186
		// Skip the boolean and the target
187
		target = arguments[ i ] || {};
188
		i++;
189
	}
190
191
	// Handle case when target is a string or something (possible in deep copy)
192
	if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
193
		target = {};
194
	}
195
196
	// Extend jQuery itself if only one argument is passed
197
	if ( i === length ) {
198
		target = this;
199
		i--;
200
	}
201
202
	for ( ; i < length; i++ ) {
203
204
		// Only deal with non-null/undefined values
205
		if ( ( options = arguments[ i ] ) != null ) {
206
207
			// Extend the base object
208
			for ( name in options ) {
209
				src = target[ name ];
210
				copy = options[ name ];
211
212
				// Prevent never-ending loop
213
				if ( target === copy ) {
214
					continue;
215
				}
216
217
				// Recurse if we're merging plain objects or arrays
218
				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
219
					( copyIsArray = jQuery.isArray( copy ) ) ) ) {
220
221
					if ( copyIsArray ) {
222
						copyIsArray = false;
223
						clone = src && jQuery.isArray( src ) ? src : [];
224
225
					} else {
226
						clone = src && jQuery.isPlainObject( src ) ? src : {};
227
					}
228
229
					// Never move original objects, clone them
230
					target[ name ] = jQuery.extend( deep, clone, copy );
231
232
				// Don't bring in undefined values
233
				} else if ( copy !== undefined ) {
234
					target[ name ] = copy;
235
				}
236
			}
237
		}
238
	}
239
240
	// Return the modified object
241
	return target;
242
};
243
244
jQuery.extend( {
245
246
	// Unique for each copy of jQuery on the page
247
	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
248
249
	// Assume jQuery is ready without the ready module
250
	isReady: true,
251
252
	error: function( msg ) {
253
		throw new Error( msg );
254
	},
255
256
	noop: function() {},
257
258
	isFunction: function( obj ) {
259
		return jQuery.type( obj ) === "function";
260
	},
261
262
	isArray: Array.isArray,
263
264
	isWindow: function( obj ) {
265
		return obj != null && obj === obj.window;
266
	},
267
268
	isNumeric: function( obj ) {
269
270
		// parseFloat NaNs numeric-cast false positives (null|true|false|"")
271
		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
272
		// subtraction forces infinities to NaN
273
		// adding 1 corrects loss of precision from parseFloat (#15100)
274
		var realStringObj = obj && obj.toString();
275
		return !jQuery.isArray( obj ) && ( realStringObj - parseFloat( realStringObj ) + 1 ) >= 0;
276
	},
277
278
	isPlainObject: function( obj ) {
279
		var key;
280
281
		// Not plain objects:
282
		// - Any object or value whose internal [[Class]] property is not "[object Object]"
283
		// - DOM nodes
284
		// - window
285
		if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
286
			return false;
287
		}
288
289
		// Not own constructor property must be Object
290
		if ( obj.constructor &&
291
				!hasOwn.call( obj, "constructor" ) &&
292
				!hasOwn.call( obj.constructor.prototype || {}, "isPrototypeOf" ) ) {
293
			return false;
294
		}
295
296
		// Own properties are enumerated firstly, so to speed up,
297
		// if last one is own, then all properties are own
298
		for ( key in obj ) {}
299
300
		return key === undefined || hasOwn.call( obj, key );
301
	},
302
303
	isEmptyObject: function( obj ) {
304
		var name;
305
		for ( name in obj ) {
306
			return false;
307
		}
308
		return true;
309
	},
310
311
	type: function( obj ) {
312
		if ( obj == null ) {
313
			return obj + "";
314
		}
315
316
		// Support: Android<4.0, iOS<6 (functionish RegExp)
317
		return typeof obj === "object" || typeof obj === "function" ?
318
			class2type[ toString.call( obj ) ] || "object" :
319
			typeof obj;
320
	},
321
322
	// Evaluates a script in a global context
323
	globalEval: function( code ) {
324
		var script,
325
			indirect = eval;
326
327
		code = jQuery.trim( code );
328
329
		if ( code ) {
330
331
			// If the code includes a valid, prologue position
332
			// strict mode pragma, execute code by injecting a
333
			// script tag into the document.
334
			if ( code.indexOf( "use strict" ) === 1 ) {
335
				script = document.createElement( "script" );
336
				script.text = code;
337
				document.head.appendChild( script ).parentNode.removeChild( script );
338
			} else {
339
340
				// Otherwise, avoid the DOM node creation, insertion
341
				// and removal by using an indirect global eval
342
343
				indirect( code );
344
			}
345
		}
346
	},
347
348
	// Convert dashed to camelCase; used by the css and data modules
349
	// Support: IE9-11+
350
	// Microsoft forgot to hump their vendor prefix (#9572)
351
	camelCase: function( string ) {
352
		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
353
	},
354
355
	nodeName: function( elem, name ) {
356
		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
357
	},
358
359
	each: function( obj, callback ) {
360
		var length, i = 0;
361
362
		if ( isArrayLike( obj ) ) {
363
			length = obj.length;
364
			for ( ; i < length; i++ ) {
365
				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
366
					break;
367
				}
368
			}
369
		} else {
370
			for ( i in obj ) {
371
				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
372
					break;
373
				}
374
			}
375
		}
376
377
		return obj;
378
	},
379
380
	// Support: Android<4.1
381
	trim: function( text ) {
382
		return text == null ?
383
			"" :
384
			( text + "" ).replace( rtrim, "" );
385
	},
386
387
	// results is for internal usage only
388
	makeArray: function( arr, results ) {
389
		var ret = results || [];
390
391
		if ( arr != null ) {
392
			if ( isArrayLike( Object( arr ) ) ) {
393
				jQuery.merge( ret,
394
					typeof arr === "string" ?
395
					[ arr ] : arr
396
				);
397
			} else {
398
				push.call( ret, arr );
399
			}
400
		}
401
402
		return ret;
403
	},
404
405
	inArray: function( elem, arr, i ) {
406
		return arr == null ? -1 : indexOf.call( arr, elem, i );
407
	},
408
409
	merge: function( first, second ) {
410
		var len = +second.length,
411
			j = 0,
412
			i = first.length;
413
414
		for ( ; j < len; j++ ) {
415
			first[ i++ ] = second[ j ];
416
		}
417
418
		first.length = i;
419
420
		return first;
421
	},
422
423
	grep: function( elems, callback, invert ) {
424
		var callbackInverse,
425
			matches = [],
426
			i = 0,
427
			length = elems.length,
428
			callbackExpect = !invert;
429
430
		// Go through the array, only saving the items
431
		// that pass the validator function
432
		for ( ; i < length; i++ ) {
433
			callbackInverse = !callback( elems[ i ], i );
434
			if ( callbackInverse !== callbackExpect ) {
435
				matches.push( elems[ i ] );
436
			}
437
		}
438
439
		return matches;
440
	},
441
442
	// arg is for internal usage only
443
	map: function( elems, callback, arg ) {
444
		var length, value,
445
			i = 0,
446
			ret = [];
447
448
		// Go through the array, translating each of the items to their new values
449
		if ( isArrayLike( elems ) ) {
450
			length = elems.length;
451
			for ( ; i < length; i++ ) {
452
				value = callback( elems[ i ], i, arg );
453
454
				if ( value != null ) {
455
					ret.push( value );
456
				}
457
			}
458
459
		// Go through every key on the object,
460
		} else {
461
			for ( i in elems ) {
462
				value = callback( elems[ i ], i, arg );
463
464
				if ( value != null ) {
465
					ret.push( value );
466
				}
467
			}
468
		}
469
470
		// Flatten any nested arrays
471
		return concat.apply( [], ret );
472
	},
473
474
	// A global GUID counter for objects
475
	guid: 1,
476
477
	// Bind a function to a context, optionally partially applying any
478
	// arguments.
479
	proxy: function( fn, context ) {
480
		var tmp, args, proxy;
481
482
		if ( typeof context === "string" ) {
483
			tmp = fn[ context ];
484
			context = fn;
485
			fn = tmp;
486
		}
487
488
		// Quick check to determine if target is callable, in the spec
489
		// this throws a TypeError, but we will just return undefined.
490
		if ( !jQuery.isFunction( fn ) ) {
491
			return undefined;
492
		}
493
494
		// Simulated bind
495
		args = slice.call( arguments, 2 );
496
		proxy = function() {
497
			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
498
		};
499
500
		// Set the guid of unique handler to the same of original handler, so it can be removed
501
		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
502
503
		return proxy;
504
	},
505
506
	now: Date.now,
507
508
	// jQuery.support is not used in Core but other projects attach their
509
	// properties to it so it needs to exist.
510
	support: support
511
} );
512
513
// JSHint would error on this code due to the Symbol not being defined in ES5.
514
// Defining this global in .jshintrc would create a danger of using the global
515
// unguarded in another place, it seems safer to just disable JSHint for these
516
// three lines.
517
/* jshint ignore: start */
518
if ( typeof Symbol === "function" ) {
519
	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
520
}
521
/* jshint ignore: end */
522
523
// Populate the class2type map
524
jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
525
function( i, name ) {
526
	class2type[ "[object " + name + "]" ] = name.toLowerCase();
527
} );
528
529
function isArrayLike( obj ) {
530
531
	// Support: iOS 8.2 (not reproducible in simulator)
532
	// `in` check used to prevent JIT error (gh-2145)
533
	// hasOwn isn't used here due to false negatives
534
	// regarding Nodelist length in IE
535
	var length = !!obj && "length" in obj && obj.length,
536
		type = jQuery.type( obj );
537
538
	if ( type === "function" || jQuery.isWindow( obj ) ) {
539
		return false;
540
	}
541
542
	return type === "array" || length === 0 ||
543
		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
544
}
545
var Sizzle =
546
/*!
547
 * Sizzle CSS Selector Engine v2.2.1
548
 * http://sizzlejs.com/
549
 *
550
 * Copyright jQuery Foundation and other contributors
551
 * Released under the MIT license
552
 * http://jquery.org/license
553
 *
554
 * Date: 2015-10-17
555
 */
556
(function( window ) {
557
558
var i,
559
	support,
560
	Expr,
561
	getText,
562
	isXML,
563
	tokenize,
564
	compile,
565
	select,
566
	outermostContext,
567
	sortInput,
568
	hasDuplicate,
569
570
	// Local document vars
571
	setDocument,
572
	document,
573
	docElem,
574
	documentIsHTML,
575
	rbuggyQSA,
576
	rbuggyMatches,
577
	matches,
578
	contains,
579
580
	// Instance-specific data
581
	expando = "sizzle" + 1 * new Date(),
582
	preferredDoc = window.document,
583
	dirruns = 0,
584
	done = 0,
585
	classCache = createCache(),
586
	tokenCache = createCache(),
587
	compilerCache = createCache(),
588
	sortOrder = function( a, b ) {
589
		if ( a === b ) {
590
			hasDuplicate = true;
591
		}
592
		return 0;
593
	},
594
595
	// General-purpose constants
596
	MAX_NEGATIVE = 1 << 31,
597
598
	// Instance methods
599
	hasOwn = ({}).hasOwnProperty,
600
	arr = [],
601
	pop = arr.pop,
602
	push_native = arr.push,
603
	push = arr.push,
604
	slice = arr.slice,
605
	// Use a stripped-down indexOf as it's faster than native
606
	// http://jsperf.com/thor-indexof-vs-for/5
607
	indexOf = function( list, elem ) {
608
		var i = 0,
609
			len = list.length;
610
		for ( ; i < len; i++ ) {
611
			if ( list[i] === elem ) {
612
				return i;
613
			}
614
		}
615
		return -1;
616
	},
617
618
	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
619
620
	// Regular expressions
621
622
	// http://www.w3.org/TR/css3-selectors/#whitespace
623
	whitespace = "[\\x20\\t\\r\\n\\f]",
624
625
	// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
626
	identifier = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
627
628
	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
629
	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
630
		// Operator (capture 2)
631
		"*([*^$|!~]?=)" + whitespace +
632
		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
633
		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
634
		"*\\]",
635
636
	pseudos = ":(" + identifier + ")(?:\\((" +
637
		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
638
		// 1. quoted (capture 3; capture 4 or capture 5)
639
		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
640
		// 2. simple (capture 6)
641
		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
642
		// 3. anything else (capture 2)
643
		".*" +
644
		")\\)|)",
645
646
	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
647
	rwhitespace = new RegExp( whitespace + "+", "g" ),
648
	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
649
650
	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
651
	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
652
653
	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
654
655
	rpseudo = new RegExp( pseudos ),
656
	ridentifier = new RegExp( "^" + identifier + "$" ),
657
658
	matchExpr = {
659
		"ID": new RegExp( "^#(" + identifier + ")" ),
660
		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
661
		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
662
		"ATTR": new RegExp( "^" + attributes ),
663
		"PSEUDO": new RegExp( "^" + pseudos ),
664
		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
665
			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
666
			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
667
		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
668
		// For use in libraries implementing .is()
669
		// We use this for POS matching in `select`
670
		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
671
			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
672
	},
673
674
	rinputs = /^(?:input|select|textarea|button)$/i,
675
	rheader = /^h\d$/i,
676
677
	rnative = /^[^{]+\{\s*\[native \w/,
678
679
	// Easily-parseable/retrievable ID or TAG or CLASS selectors
680
	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
681
682
	rsibling = /[+~]/,
683
	rescape = /'|\\/g,
684
685
	// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
686
	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
687
	funescape = function( _, escaped, escapedWhitespace ) {
688
		var high = "0x" + escaped - 0x10000;
689
		// NaN means non-codepoint
690
		// Support: Firefox<24
691
		// Workaround erroneous numeric interpretation of +"0x"
692
		return high !== high || escapedWhitespace ?
693
			escaped :
694
			high < 0 ?
695
				// BMP codepoint
696
				String.fromCharCode( high + 0x10000 ) :
697
				// Supplemental Plane codepoint (surrogate pair)
698
				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
699
	},
700
701
	// Used for iframes
702
	// See setDocument()
703
	// Removing the function wrapper causes a "Permission Denied"
704
	// error in IE
705
	unloadHandler = function() {
706
		setDocument();
707
	};
708
709
// Optimize for push.apply( _, NodeList )
710
try {
711
	push.apply(
712
		(arr = slice.call( preferredDoc.childNodes )),
713
		preferredDoc.childNodes
714
	);
715
	// Support: Android<4.0
716
	// Detect silently failing push.apply
717
	arr[ preferredDoc.childNodes.length ].nodeType;
718
} catch ( e ) {
719
	push = { apply: arr.length ?
720
721
		// Leverage slice if possible
722
		function( target, els ) {
723
			push_native.apply( target, slice.call(els) );
724
		} :
725
726
		// Support: IE<9
727
		// Otherwise append directly
728
		function( target, els ) {
729
			var j = target.length,
730
				i = 0;
731
			// Can't trust NodeList.length
732
			while ( (target[j++] = els[i++]) ) {}
733
			target.length = j - 1;
734
		}
735
	};
736
}
737
738
function Sizzle( selector, context, results, seed ) {
739
	var m, i, elem, nid, nidselect, match, groups, newSelector,
740
		newContext = context && context.ownerDocument,
741
742
		// nodeType defaults to 9, since context defaults to document
743
		nodeType = context ? context.nodeType : 9;
744
745
	results = results || [];
746
747
	// Return early from calls with invalid selector or context
748
	if ( typeof selector !== "string" || !selector ||
749
		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
750
751
		return results;
752
	}
753
754
	// Try to shortcut find operations (as opposed to filters) in HTML documents
755
	if ( !seed ) {
756
757
		if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
758
			setDocument( context );
759
		}
760
		context = context || document;
761
762
		if ( documentIsHTML ) {
763
764
			// If the selector is sufficiently simple, try using a "get*By*" DOM method
765
			// (excepting DocumentFragment context, where the methods don't exist)
766
			if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
767
768
				// ID selector
769
				if ( (m = match[1]) ) {
770
771
					// Document context
772
					if ( nodeType === 9 ) {
773
						if ( (elem = context.getElementById( m )) ) {
774
775
							// Support: IE, Opera, Webkit
776
							// TODO: identify versions
777
							// getElementById can match elements by name instead of ID
778
							if ( elem.id === m ) {
779
								results.push( elem );
780
								return results;
781
							}
782
						} else {
783
							return results;
784
						}
785
786
					// Element context
787
					} else {
788
789
						// Support: IE, Opera, Webkit
790
						// TODO: identify versions
791
						// getElementById can match elements by name instead of ID
792
						if ( newContext && (elem = newContext.getElementById( m )) &&
793
							contains( context, elem ) &&
794
							elem.id === m ) {
795
796
							results.push( elem );
797
							return results;
798
						}
799
					}
800
801
				// Type selector
802
				} else if ( match[2] ) {
803
					push.apply( results, context.getElementsByTagName( selector ) );
804
					return results;
805
806
				// Class selector
807
				} else if ( (m = match[3]) && support.getElementsByClassName &&
808
					context.getElementsByClassName ) {
809
810
					push.apply( results, context.getElementsByClassName( m ) );
811
					return results;
812
				}
813
			}
814
815
			// Take advantage of querySelectorAll
816
			if ( support.qsa &&
817
				!compilerCache[ selector + " " ] &&
818
				(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
819
820
				if ( nodeType !== 1 ) {
821
					newContext = context;
822
					newSelector = selector;
823
824
				// qSA looks outside Element context, which is not what we want
825
				// Thanks to Andrew Dupont for this workaround technique
826
				// Support: IE <=8
827
				// Exclude object elements
828
				} else if ( context.nodeName.toLowerCase() !== "object" ) {
829
830
					// Capture the context ID, setting it first if necessary
831
					if ( (nid = context.getAttribute( "id" )) ) {
832
						nid = nid.replace( rescape, "\\$&" );
833
					} else {
834
						context.setAttribute( "id", (nid = expando) );
835
					}
836
837
					// Prefix every selector in the list
838
					groups = tokenize( selector );
839
					i = groups.length;
840
					nidselect = ridentifier.test( nid ) ? "#" + nid : "[id='" + nid + "']";
841
					while ( i-- ) {
842
						groups[i] = nidselect + " " + toSelector( groups[i] );
843
					}
844
					newSelector = groups.join( "," );
845
846
					// Expand context for sibling selectors
847
					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
848
						context;
849
				}
850
851
				if ( newSelector ) {
852
					try {
853
						push.apply( results,
854
							newContext.querySelectorAll( newSelector )
855
						);
856
						return results;
857
					} catch ( qsaError ) {
858
					} finally {
859
						if ( nid === expando ) {
860
							context.removeAttribute( "id" );
861
						}
862
					}
863
				}
864
			}
865
		}
866
	}
867
868
	// All others
869
	return select( selector.replace( rtrim, "$1" ), context, results, seed );
870
}
871
872
/**
873
 * Create key-value caches of limited size
874
 * @returns {function(string, object)} Returns the Object data after storing it on itself with
875
 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
876
 *	deleting the oldest entry
877
 */
878
function createCache() {
879
	var keys = [];
880
881
	function cache( key, value ) {
882
		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
883
		if ( keys.push( key + " " ) > Expr.cacheLength ) {
884
			// Only keep the most recent entries
885
			delete cache[ keys.shift() ];
886
		}
887
		return (cache[ key + " " ] = value);
888
	}
889
	return cache;
890
}
891
892
/**
893
 * Mark a function for special use by Sizzle
894
 * @param {Function} fn The function to mark
895
 */
896
function markFunction( fn ) {
897
	fn[ expando ] = true;
898
	return fn;
899
}
900
901
/**
902
 * Support testing using an element
903
 * @param {Function} fn Passed the created div and expects a boolean result
904
 */
905
function assert( fn ) {
906
	var div = document.createElement("div");
907
908
	try {
909
		return !!fn( div );
910
	} catch (e) {
911
		return false;
912
	} finally {
913
		// Remove from its parent by default
914
		if ( div.parentNode ) {
915
			div.parentNode.removeChild( div );
916
		}
917
		// release memory in IE
918
		div = null;
919
	}
920
}
921
922
/**
923
 * Adds the same handler for all of the specified attrs
924
 * @param {String} attrs Pipe-separated list of attributes
925
 * @param {Function} handler The method that will be applied
926
 */
927
function addHandle( attrs, handler ) {
928
	var arr = attrs.split("|"),
929
		i = arr.length;
930
931
	while ( i-- ) {
932
		Expr.attrHandle[ arr[i] ] = handler;
933
	}
934
}
935
936
/**
937
 * Checks document order of two siblings
938
 * @param {Element} a
939
 * @param {Element} b
940
 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
941
 */
942
function siblingCheck( a, b ) {
943
	var cur = b && a,
944
		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
945
			( ~b.sourceIndex || MAX_NEGATIVE ) -
946
			( ~a.sourceIndex || MAX_NEGATIVE );
947
948
	// Use IE sourceIndex if available on both nodes
949
	if ( diff ) {
950
		return diff;
951
	}
952
953
	// Check if b follows a
954
	if ( cur ) {
955
		while ( (cur = cur.nextSibling) ) {
956
			if ( cur === b ) {
957
				return -1;
958
			}
959
		}
960
	}
961
962
	return a ? 1 : -1;
963
}
964
965
/**
966
 * Returns a function to use in pseudos for input types
967
 * @param {String} type
968
 */
969
function createInputPseudo( type ) {
970
	return function( elem ) {
971
		var name = elem.nodeName.toLowerCase();
972
		return name === "input" && elem.type === type;
973
	};
974
}
975
976
/**
977
 * Returns a function to use in pseudos for buttons
978
 * @param {String} type
979
 */
980
function createButtonPseudo( type ) {
981
	return function( elem ) {
982
		var name = elem.nodeName.toLowerCase();
983
		return (name === "input" || name === "button") && elem.type === type;
984
	};
985
}
986
987
/**
988
 * Returns a function to use in pseudos for positionals
989
 * @param {Function} fn
990
 */
991
function createPositionalPseudo( fn ) {
992
	return markFunction(function( argument ) {
993
		argument = +argument;
994
		return markFunction(function( seed, matches ) {
995
			var j,
996
				matchIndexes = fn( [], seed.length, argument ),
997
				i = matchIndexes.length;
998
999
			// Match elements found at the specified indexes
1000
			while ( i-- ) {
1001
				if ( seed[ (j = matchIndexes[i]) ] ) {
1002
					seed[j] = !(matches[j] = seed[j]);
1003
				}
1004
			}
1005
		});
1006
	});
1007
}
1008
1009
/**
1010
 * Checks a node for validity as a Sizzle context
1011
 * @param {Element|Object=} context
1012
 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1013
 */
1014
function testContext( context ) {
1015
	return context && typeof context.getElementsByTagName !== "undefined" && context;
1016
}
1017
1018
// Expose support vars for convenience
1019
support = Sizzle.support = {};
1020
1021
/**
1022
 * Detects XML nodes
1023
 * @param {Element|Object} elem An element or a document
1024
 * @returns {Boolean} True iff elem is a non-HTML XML node
1025
 */
1026
isXML = Sizzle.isXML = function( elem ) {
1027
	// documentElement is verified for cases where it doesn't yet exist
1028
	// (such as loading iframes in IE - #4833)
1029
	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1030
	return documentElement ? documentElement.nodeName !== "HTML" : false;
1031
};
1032
1033
/**
1034
 * Sets document-related variables once based on the current document
1035
 * @param {Element|Object} [doc] An element or document object to use to set the document
1036
 * @returns {Object} Returns the current document
1037
 */
1038
setDocument = Sizzle.setDocument = function( node ) {
1039
	var hasCompare, parent,
1040
		doc = node ? node.ownerDocument || node : preferredDoc;
1041
1042
	// Return early if doc is invalid or already selected
1043
	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1044
		return document;
1045
	}
1046
1047
	// Update global variables
1048
	document = doc;
1049
	docElem = document.documentElement;
1050
	documentIsHTML = !isXML( document );
1051
1052
	// Support: IE 9-11, Edge
1053
	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1054
	if ( (parent = document.defaultView) && parent.top !== parent ) {
1055
		// Support: IE 11
1056
		if ( parent.addEventListener ) {
1057
			parent.addEventListener( "unload", unloadHandler, false );
1058
1059
		// Support: IE 9 - 10 only
1060
		} else if ( parent.attachEvent ) {
1061
			parent.attachEvent( "onunload", unloadHandler );
1062
		}
1063
	}
1064
1065
	/* Attributes
1066
	---------------------------------------------------------------------- */
1067
1068
	// Support: IE<8
1069
	// Verify that getAttribute really returns attributes and not properties
1070
	// (excepting IE8 booleans)
1071
	support.attributes = assert(function( div ) {
1072
		div.className = "i";
1073
		return !div.getAttribute("className");
1074
	});
1075
1076
	/* getElement(s)By*
1077
	---------------------------------------------------------------------- */
1078
1079
	// Check if getElementsByTagName("*") returns only elements
1080
	support.getElementsByTagName = assert(function( div ) {
1081
		div.appendChild( document.createComment("") );
1082
		return !div.getElementsByTagName("*").length;
1083
	});
1084
1085
	// Support: IE<9
1086
	support.getElementsByClassName = rnative.test( document.getElementsByClassName );
1087
1088
	// Support: IE<10
1089
	// Check if getElementById returns elements by name
1090
	// The broken getElementById methods don't pick up programatically-set names,
1091
	// so use a roundabout getElementsByName test
1092
	support.getById = assert(function( div ) {
1093
		docElem.appendChild( div ).id = expando;
1094
		return !document.getElementsByName || !document.getElementsByName( expando ).length;
1095
	});
1096
1097
	// ID find and filter
1098
	if ( support.getById ) {
1099
		Expr.find["ID"] = function( id, context ) {
1100
			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1101
				var m = context.getElementById( id );
1102
				return m ? [ m ] : [];
1103
			}
1104
		};
1105
		Expr.filter["ID"] = function( id ) {
1106
			var attrId = id.replace( runescape, funescape );
1107
			return function( elem ) {
1108
				return elem.getAttribute("id") === attrId;
1109
			};
1110
		};
1111
	} else {
1112
		// Support: IE6/7
1113
		// getElementById is not reliable as a find shortcut
1114
		delete Expr.find["ID"];
1115
1116
		Expr.filter["ID"] =  function( id ) {
1117
			var attrId = id.replace( runescape, funescape );
1118
			return function( elem ) {
1119
				var node = typeof elem.getAttributeNode !== "undefined" &&
1120
					elem.getAttributeNode("id");
1121
				return node && node.value === attrId;
1122
			};
1123
		};
1124
	}
1125
1126
	// Tag
1127
	Expr.find["TAG"] = support.getElementsByTagName ?
1128
		function( tag, context ) {
1129
			if ( typeof context.getElementsByTagName !== "undefined" ) {
1130
				return context.getElementsByTagName( tag );
1131
1132
			// DocumentFragment nodes don't have gEBTN
1133
			} else if ( support.qsa ) {
1134
				return context.querySelectorAll( tag );
1135
			}
1136
		} :
1137
1138
		function( tag, context ) {
1139
			var elem,
1140
				tmp = [],
1141
				i = 0,
1142
				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1143
				results = context.getElementsByTagName( tag );
1144
1145
			// Filter out possible comments
1146
			if ( tag === "*" ) {
1147
				while ( (elem = results[i++]) ) {
1148
					if ( elem.nodeType === 1 ) {
1149
						tmp.push( elem );
1150
					}
1151
				}
1152
1153
				return tmp;
1154
			}
1155
			return results;
1156
		};
1157
1158
	// Class
1159
	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1160
		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1161
			return context.getElementsByClassName( className );
1162
		}
1163
	};
1164
1165
	/* QSA/matchesSelector
1166
	---------------------------------------------------------------------- */
1167
1168
	// QSA and matchesSelector support
1169
1170
	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1171
	rbuggyMatches = [];
1172
1173
	// qSa(:focus) reports false when true (Chrome 21)
1174
	// We allow this because of a bug in IE8/9 that throws an error
1175
	// whenever `document.activeElement` is accessed on an iframe
1176
	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1177
	// See http://bugs.jquery.com/ticket/13378
1178
	rbuggyQSA = [];
1179
1180
	if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
1181
		// Build QSA regex
1182
		// Regex strategy adopted from Diego Perini
1183
		assert(function( div ) {
1184
			// Select is set to empty string on purpose
1185
			// This is to test IE's treatment of not explicitly
1186
			// setting a boolean content attribute,
1187
			// since its presence should be enough
1188
			// http://bugs.jquery.com/ticket/12359
1189
			docElem.appendChild( div ).innerHTML = "<a id='" + expando + "'></a>" +
1190
				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
1191
				"<option selected=''></option></select>";
1192
1193
			// Support: IE8, Opera 11-12.16
1194
			// Nothing should be selected when empty strings follow ^= or $= or *=
1195
			// The test attribute must be unknown in Opera but "safe" for WinRT
1196
			// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1197
			if ( div.querySelectorAll("[msallowcapture^='']").length ) {
1198
				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1199
			}
1200
1201
			// Support: IE8
1202
			// Boolean attributes and "value" are not treated correctly
1203
			if ( !div.querySelectorAll("[selected]").length ) {
1204
				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1205
			}
1206
1207
			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1208
			if ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1209
				rbuggyQSA.push("~=");
1210
			}
1211
1212
			// Webkit/Opera - :checked should return selected option elements
1213
			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1214
			// IE8 throws error here and will not see later tests
1215
			if ( !div.querySelectorAll(":checked").length ) {
1216
				rbuggyQSA.push(":checked");
1217
			}
1218
1219
			// Support: Safari 8+, iOS 8+
1220
			// https://bugs.webkit.org/show_bug.cgi?id=136851
1221
			// In-page `selector#id sibing-combinator selector` fails
1222
			if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) {
1223
				rbuggyQSA.push(".#.+[+~]");
1224
			}
1225
		});
1226
1227
		assert(function( div ) {
1228
			// Support: Windows 8 Native Apps
1229
			// The type and name attributes are restricted during .innerHTML assignment
1230
			var input = document.createElement("input");
1231
			input.setAttribute( "type", "hidden" );
1232
			div.appendChild( input ).setAttribute( "name", "D" );
1233
1234
			// Support: IE8
1235
			// Enforce case-sensitivity of name attribute
1236
			if ( div.querySelectorAll("[name=d]").length ) {
1237
				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1238
			}
1239
1240
			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1241
			// IE8 throws error here and will not see later tests
1242
			if ( !div.querySelectorAll(":enabled").length ) {
1243
				rbuggyQSA.push( ":enabled", ":disabled" );
1244
			}
1245
1246
			// Opera 10-11 does not throw on post-comma invalid pseudos
1247
			div.querySelectorAll("*,:x");
1248
			rbuggyQSA.push(",.*:");
1249
		});
1250
	}
1251
1252
	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
1253
		docElem.webkitMatchesSelector ||
1254
		docElem.mozMatchesSelector ||
1255
		docElem.oMatchesSelector ||
1256
		docElem.msMatchesSelector) )) ) {
1257
1258
		assert(function( div ) {
1259
			// Check to see if it's possible to do matchesSelector
1260
			// on a disconnected node (IE 9)
1261
			support.disconnectedMatch = matches.call( div, "div" );
1262
1263
			// This should fail with an exception
1264
			// Gecko does not error, returns false instead
1265
			matches.call( div, "[s!='']:x" );
1266
			rbuggyMatches.push( "!=", pseudos );
1267
		});
1268
	}
1269
1270
	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1271
	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1272
1273
	/* Contains
1274
	---------------------------------------------------------------------- */
1275
	hasCompare = rnative.test( docElem.compareDocumentPosition );
1276
1277
	// Element contains another
1278
	// Purposefully self-exclusive
1279
	// As in, an element does not contain itself
1280
	contains = hasCompare || rnative.test( docElem.contains ) ?
1281
		function( a, b ) {
1282
			var adown = a.nodeType === 9 ? a.documentElement : a,
1283
				bup = b && b.parentNode;
1284
			return a === bup || !!( bup && bup.nodeType === 1 && (
1285
				adown.contains ?
1286
					adown.contains( bup ) :
1287
					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1288
			));
1289
		} :
1290
		function( a, b ) {
1291
			if ( b ) {
1292
				while ( (b = b.parentNode) ) {
1293
					if ( b === a ) {
1294
						return true;
1295
					}
1296
				}
1297
			}
1298
			return false;
1299
		};
1300
1301
	/* Sorting
1302
	---------------------------------------------------------------------- */
1303
1304
	// Document order sorting
1305
	sortOrder = hasCompare ?
1306
	function( a, b ) {
1307
1308
		// Flag for duplicate removal
1309
		if ( a === b ) {
1310
			hasDuplicate = true;
1311
			return 0;
1312
		}
1313
1314
		// Sort on method existence if only one input has compareDocumentPosition
1315
		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1316
		if ( compare ) {
1317
			return compare;
1318
		}
1319
1320
		// Calculate position if both inputs belong to the same document
1321
		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1322
			a.compareDocumentPosition( b ) :
1323
1324
			// Otherwise we know they are disconnected
1325
			1;
1326
1327
		// Disconnected nodes
1328
		if ( compare & 1 ||
1329
			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1330
1331
			// Choose the first element that is related to our preferred document
1332
			if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1333
				return -1;
1334
			}
1335
			if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1336
				return 1;
1337
			}
1338
1339
			// Maintain original order
1340
			return sortInput ?
1341
				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1342
				0;
1343
		}
1344
1345
		return compare & 4 ? -1 : 1;
1346
	} :
1347
	function( a, b ) {
1348
		// Exit early if the nodes are identical
1349
		if ( a === b ) {
1350
			hasDuplicate = true;
1351
			return 0;
1352
		}
1353
1354
		var cur,
1355
			i = 0,
1356
			aup = a.parentNode,
1357
			bup = b.parentNode,
1358
			ap = [ a ],
1359
			bp = [ b ];
1360
1361
		// Parentless nodes are either documents or disconnected
1362
		if ( !aup || !bup ) {
1363
			return a === document ? -1 :
1364
				b === document ? 1 :
1365
				aup ? -1 :
1366
				bup ? 1 :
1367
				sortInput ?
1368
				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1369
				0;
1370
1371
		// If the nodes are siblings, we can do a quick check
1372
		} else if ( aup === bup ) {
1373
			return siblingCheck( a, b );
1374
		}
1375
1376
		// Otherwise we need full lists of their ancestors for comparison
1377
		cur = a;
1378
		while ( (cur = cur.parentNode) ) {
1379
			ap.unshift( cur );
1380
		}
1381
		cur = b;
1382
		while ( (cur = cur.parentNode) ) {
1383
			bp.unshift( cur );
1384
		}
1385
1386
		// Walk down the tree looking for a discrepancy
1387
		while ( ap[i] === bp[i] ) {
1388
			i++;
1389
		}
1390
1391
		return i ?
1392
			// Do a sibling check if the nodes have a common ancestor
1393
			siblingCheck( ap[i], bp[i] ) :
1394
1395
			// Otherwise nodes in our document sort first
1396
			ap[i] === preferredDoc ? -1 :
1397
			bp[i] === preferredDoc ? 1 :
1398
			0;
1399
	};
1400
1401
	return document;
1402
};
1403
1404
Sizzle.matches = function( expr, elements ) {
1405
	return Sizzle( expr, null, null, elements );
1406
};
1407
1408
Sizzle.matchesSelector = function( elem, expr ) {
1409
	// Set document vars if needed
1410
	if ( ( elem.ownerDocument || elem ) !== document ) {
1411
		setDocument( elem );
1412
	}
1413
1414
	// Make sure that attribute selectors are quoted
1415
	expr = expr.replace( rattributeQuotes, "='$1']" );
1416
1417
	if ( support.matchesSelector && documentIsHTML &&
1418
		!compilerCache[ expr + " " ] &&
1419
		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1420
		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1421
1422
		try {
1423
			var ret = matches.call( elem, expr );
1424
1425
			// IE 9's matchesSelector returns false on disconnected nodes
1426
			if ( ret || support.disconnectedMatch ||
1427
					// As well, disconnected nodes are said to be in a document
1428
					// fragment in IE 9
1429
					elem.document && elem.document.nodeType !== 11 ) {
1430
				return ret;
1431
			}
1432
		} catch (e) {}
1433
	}
1434
1435
	return Sizzle( expr, document, null, [ elem ] ).length > 0;
1436
};
1437
1438
Sizzle.contains = function( context, elem ) {
1439
	// Set document vars if needed
1440
	if ( ( context.ownerDocument || context ) !== document ) {
1441
		setDocument( context );
1442
	}
1443
	return contains( context, elem );
1444
};
1445
1446
Sizzle.attr = function( elem, name ) {
1447
	// Set document vars if needed
1448
	if ( ( elem.ownerDocument || elem ) !== document ) {
1449
		setDocument( elem );
1450
	}
1451
1452
	var fn = Expr.attrHandle[ name.toLowerCase() ],
1453
		// Don't get fooled by Object.prototype properties (jQuery #13807)
1454
		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1455
			fn( elem, name, !documentIsHTML ) :
1456
			undefined;
1457
1458
	return val !== undefined ?
1459
		val :
1460
		support.attributes || !documentIsHTML ?
1461
			elem.getAttribute( name ) :
1462
			(val = elem.getAttributeNode(name)) && val.specified ?
1463
				val.value :
1464
				null;
1465
};
1466
1467
Sizzle.error = function( msg ) {
1468
	throw new Error( "Syntax error, unrecognized expression: " + msg );
1469
};
1470
1471
/**
1472
 * Document sorting and removing duplicates
1473
 * @param {ArrayLike} results
1474
 */
1475
Sizzle.uniqueSort = function( results ) {
1476
	var elem,
1477
		duplicates = [],
1478
		j = 0,
1479
		i = 0;
1480
1481
	// Unless we *know* we can detect duplicates, assume their presence
1482
	hasDuplicate = !support.detectDuplicates;
1483
	sortInput = !support.sortStable && results.slice( 0 );
1484
	results.sort( sortOrder );
1485
1486
	if ( hasDuplicate ) {
1487
		while ( (elem = results[i++]) ) {
1488
			if ( elem === results[ i ] ) {
1489
				j = duplicates.push( i );
1490
			}
1491
		}
1492
		while ( j-- ) {
1493
			results.splice( duplicates[ j ], 1 );
1494
		}
1495
	}
1496
1497
	// Clear input after sorting to release objects
1498
	// See https://github.com/jquery/sizzle/pull/225
1499
	sortInput = null;
1500
1501
	return results;
1502
};
1503
1504
/**
1505
 * Utility function for retrieving the text value of an array of DOM nodes
1506
 * @param {Array|Element} elem
1507
 */
1508
getText = Sizzle.getText = function( elem ) {
1509
	var node,
1510
		ret = "",
1511
		i = 0,
1512
		nodeType = elem.nodeType;
1513
1514
	if ( !nodeType ) {
1515
		// If no nodeType, this is expected to be an array
1516
		while ( (node = elem[i++]) ) {
1517
			// Do not traverse comment nodes
1518
			ret += getText( node );
1519
		}
1520
	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1521
		// Use textContent for elements
1522
		// innerText usage removed for consistency of new lines (jQuery #11153)
1523
		if ( typeof elem.textContent === "string" ) {
1524
			return elem.textContent;
1525
		} else {
1526
			// Traverse its children
1527
			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1528
				ret += getText( elem );
1529
			}
1530
		}
1531
	} else if ( nodeType === 3 || nodeType === 4 ) {
1532
		return elem.nodeValue;
1533
	}
1534
	// Do not include comment or processing instruction nodes
1535
1536
	return ret;
1537
};
1538
1539
Expr = Sizzle.selectors = {
1540
1541
	// Can be adjusted by the user
1542
	cacheLength: 50,
1543
1544
	createPseudo: markFunction,
1545
1546
	match: matchExpr,
1547
1548
	attrHandle: {},
1549
1550
	find: {},
1551
1552
	relative: {
1553
		">": { dir: "parentNode", first: true },
1554
		" ": { dir: "parentNode" },
1555
		"+": { dir: "previousSibling", first: true },
1556
		"~": { dir: "previousSibling" }
1557
	},
1558
1559
	preFilter: {
1560
		"ATTR": function( match ) {
1561
			match[1] = match[1].replace( runescape, funescape );
1562
1563
			// Move the given value to match[3] whether quoted or unquoted
1564
			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
1565
1566
			if ( match[2] === "~=" ) {
1567
				match[3] = " " + match[3] + " ";
1568
			}
1569
1570
			return match.slice( 0, 4 );
1571
		},
1572
1573
		"CHILD": function( match ) {
1574
			/* matches from matchExpr["CHILD"]
1575
				1 type (only|nth|...)
1576
				2 what (child|of-type)
1577
				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1578
				4 xn-component of xn+y argument ([+-]?\d*n|)
1579
				5 sign of xn-component
1580
				6 x of xn-component
1581
				7 sign of y-component
1582
				8 y of y-component
1583
			*/
1584
			match[1] = match[1].toLowerCase();
1585
1586
			if ( match[1].slice( 0, 3 ) === "nth" ) {
1587
				// nth-* requires argument
1588
				if ( !match[3] ) {
1589
					Sizzle.error( match[0] );
1590
				}
1591
1592
				// numeric x and y parameters for Expr.filter.CHILD
1593
				// remember that false/true cast respectively to 0/1
1594
				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1595
				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1596
1597
			// other types prohibit arguments
1598
			} else if ( match[3] ) {
1599
				Sizzle.error( match[0] );
1600
			}
1601
1602
			return match;
1603
		},
1604
1605
		"PSEUDO": function( match ) {
1606
			var excess,
1607
				unquoted = !match[6] && match[2];
1608
1609
			if ( matchExpr["CHILD"].test( match[0] ) ) {
1610
				return null;
1611
			}
1612
1613
			// Accept quoted arguments as-is
1614
			if ( match[3] ) {
1615
				match[2] = match[4] || match[5] || "";
1616
1617
			// Strip excess characters from unquoted arguments
1618
			} else if ( unquoted && rpseudo.test( unquoted ) &&
1619
				// Get excess from tokenize (recursively)
1620
				(excess = tokenize( unquoted, true )) &&
1621
				// advance to the next closing parenthesis
1622
				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1623
1624
				// excess is a negative index
1625
				match[0] = match[0].slice( 0, excess );
1626
				match[2] = unquoted.slice( 0, excess );
1627
			}
1628
1629
			// Return only captures needed by the pseudo filter method (type and argument)
1630
			return match.slice( 0, 3 );
1631
		}
1632
	},
1633
1634
	filter: {
1635
1636
		"TAG": function( nodeNameSelector ) {
1637
			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1638
			return nodeNameSelector === "*" ?
1639
				function() { return true; } :
1640
				function( elem ) {
1641
					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1642
				};
1643
		},
1644
1645
		"CLASS": function( className ) {
1646
			var pattern = classCache[ className + " " ];
1647
1648
			return pattern ||
1649
				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1650
				classCache( className, function( elem ) {
1651
					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
1652
				});
1653
		},
1654
1655
		"ATTR": function( name, operator, check ) {
1656
			return function( elem ) {
1657
				var result = Sizzle.attr( elem, name );
1658
1659
				if ( result == null ) {
1660
					return operator === "!=";
1661
				}
1662
				if ( !operator ) {
1663
					return true;
1664
				}
1665
1666
				result += "";
1667
1668
				return operator === "=" ? result === check :
1669
					operator === "!=" ? result !== check :
1670
					operator === "^=" ? check && result.indexOf( check ) === 0 :
1671
					operator === "*=" ? check && result.indexOf( check ) > -1 :
1672
					operator === "$=" ? check && result.slice( -check.length ) === check :
1673
					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1674
					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1675
					false;
1676
			};
1677
		},
1678
1679
		"CHILD": function( type, what, argument, first, last ) {
1680
			var simple = type.slice( 0, 3 ) !== "nth",
1681
				forward = type.slice( -4 ) !== "last",
1682
				ofType = what === "of-type";
1683
1684
			return first === 1 && last === 0 ?
1685
1686
				// Shortcut for :nth-*(n)
1687
				function( elem ) {
1688
					return !!elem.parentNode;
1689
				} :
1690
1691
				function( elem, context, xml ) {
1692
					var cache, uniqueCache, outerCache, node, nodeIndex, start,
1693
						dir = simple !== forward ? "nextSibling" : "previousSibling",
1694
						parent = elem.parentNode,
1695
						name = ofType && elem.nodeName.toLowerCase(),
1696
						useCache = !xml && !ofType,
1697
						diff = false;
1698
1699
					if ( parent ) {
1700
1701
						// :(first|last|only)-(child|of-type)
1702
						if ( simple ) {
1703
							while ( dir ) {
1704
								node = elem;
1705
								while ( (node = node[ dir ]) ) {
1706
									if ( ofType ?
1707
										node.nodeName.toLowerCase() === name :
1708
										node.nodeType === 1 ) {
1709
1710
										return false;
1711
									}
1712
								}
1713
								// Reverse direction for :only-* (if we haven't yet done so)
1714
								start = dir = type === "only" && !start && "nextSibling";
1715
							}
1716
							return true;
1717
						}
1718
1719
						start = [ forward ? parent.firstChild : parent.lastChild ];
1720
1721
						// non-xml :nth-child(...) stores cache data on `parent`
1722
						if ( forward && useCache ) {
1723
1724
							// Seek `elem` from a previously-cached index
1725
1726
							// ...in a gzip-friendly way
1727
							node = parent;
1728
							outerCache = node[ expando ] || (node[ expando ] = {});
1729
1730
							// Support: IE <9 only
1731
							// Defend against cloned attroperties (jQuery gh-1709)
1732
							uniqueCache = outerCache[ node.uniqueID ] ||
1733
								(outerCache[ node.uniqueID ] = {});
1734
1735
							cache = uniqueCache[ type ] || [];
1736
							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1737
							diff = nodeIndex && cache[ 2 ];
1738
							node = nodeIndex && parent.childNodes[ nodeIndex ];
1739
1740
							while ( (node = ++nodeIndex && node && node[ dir ] ||
1741
1742
								// Fallback to seeking `elem` from the start
1743
								(diff = nodeIndex = 0) || start.pop()) ) {
1744
1745
								// When found, cache indexes on `parent` and break
1746
								if ( node.nodeType === 1 && ++diff && node === elem ) {
1747
									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1748
									break;
1749
								}
1750
							}
1751
1752
						} else {
1753
							// Use previously-cached element index if available
1754
							if ( useCache ) {
1755
								// ...in a gzip-friendly way
1756
								node = elem;
1757
								outerCache = node[ expando ] || (node[ expando ] = {});
1758
1759
								// Support: IE <9 only
1760
								// Defend against cloned attroperties (jQuery gh-1709)
1761
								uniqueCache = outerCache[ node.uniqueID ] ||
1762
									(outerCache[ node.uniqueID ] = {});
1763
1764
								cache = uniqueCache[ type ] || [];
1765
								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1766
								diff = nodeIndex;
1767
							}
1768
1769
							// xml :nth-child(...)
1770
							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
1771
							if ( diff === false ) {
1772
								// Use the same loop as above to seek `elem` from the start
1773
								while ( (node = ++nodeIndex && node && node[ dir ] ||
1774
									(diff = nodeIndex = 0) || start.pop()) ) {
1775
1776
									if ( ( ofType ?
1777
										node.nodeName.toLowerCase() === name :
1778
										node.nodeType === 1 ) &&
1779
										++diff ) {
1780
1781
										// Cache the index of each encountered element
1782
										if ( useCache ) {
1783
											outerCache = node[ expando ] || (node[ expando ] = {});
1784
1785
											// Support: IE <9 only
1786
											// Defend against cloned attroperties (jQuery gh-1709)
1787
											uniqueCache = outerCache[ node.uniqueID ] ||
1788
												(outerCache[ node.uniqueID ] = {});
1789
1790
											uniqueCache[ type ] = [ dirruns, diff ];
1791
										}
1792
1793
										if ( node === elem ) {
1794
											break;
1795
										}
1796
									}
1797
								}
1798
							}
1799
						}
1800
1801
						// Incorporate the offset, then check against cycle size
1802
						diff -= last;
1803
						return diff === first || ( diff % first === 0 && diff / first >= 0 );
1804
					}
1805
				};
1806
		},
1807
1808
		"PSEUDO": function( pseudo, argument ) {
1809
			// pseudo-class names are case-insensitive
1810
			// http://www.w3.org/TR/selectors/#pseudo-classes
1811
			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1812
			// Remember that setFilters inherits from pseudos
1813
			var args,
1814
				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1815
					Sizzle.error( "unsupported pseudo: " + pseudo );
1816
1817
			// The user may use createPseudo to indicate that
1818
			// arguments are needed to create the filter function
1819
			// just as Sizzle does
1820
			if ( fn[ expando ] ) {
1821
				return fn( argument );
1822
			}
1823
1824
			// But maintain support for old signatures
1825
			if ( fn.length > 1 ) {
1826
				args = [ pseudo, pseudo, "", argument ];
1827
				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
1828
					markFunction(function( seed, matches ) {
1829
						var idx,
1830
							matched = fn( seed, argument ),
1831
							i = matched.length;
1832
						while ( i-- ) {
1833
							idx = indexOf( seed, matched[i] );
1834
							seed[ idx ] = !( matches[ idx ] = matched[i] );
1835
						}
1836
					}) :
1837
					function( elem ) {
1838
						return fn( elem, 0, args );
1839
					};
1840
			}
1841
1842
			return fn;
1843
		}
1844
	},
1845
1846
	pseudos: {
1847
		// Potentially complex pseudos
1848
		"not": markFunction(function( selector ) {
1849
			// Trim the selector passed to compile
1850
			// to avoid treating leading and trailing
1851
			// spaces as combinators
1852
			var input = [],
1853
				results = [],
1854
				matcher = compile( selector.replace( rtrim, "$1" ) );
1855
1856
			return matcher[ expando ] ?
1857
				markFunction(function( seed, matches, context, xml ) {
1858
					var elem,
1859
						unmatched = matcher( seed, null, xml, [] ),
1860
						i = seed.length;
1861
1862
					// Match elements unmatched by `matcher`
1863
					while ( i-- ) {
1864
						if ( (elem = unmatched[i]) ) {
1865
							seed[i] = !(matches[i] = elem);
1866
						}
1867
					}
1868
				}) :
1869
				function( elem, context, xml ) {
1870
					input[0] = elem;
1871
					matcher( input, null, xml, results );
1872
					// Don't keep the element (issue #299)
1873
					input[0] = null;
1874
					return !results.pop();
1875
				};
1876
		}),
1877
1878
		"has": markFunction(function( selector ) {
1879
			return function( elem ) {
1880
				return Sizzle( selector, elem ).length > 0;
1881
			};
1882
		}),
1883
1884
		"contains": markFunction(function( text ) {
1885
			text = text.replace( runescape, funescape );
1886
			return function( elem ) {
1887
				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
1888
			};
1889
		}),
1890
1891
		// "Whether an element is represented by a :lang() selector
1892
		// is based solely on the element's language value
1893
		// being equal to the identifier C,
1894
		// or beginning with the identifier C immediately followed by "-".
1895
		// The matching of C against the element's language value is performed case-insensitively.
1896
		// The identifier C does not have to be a valid language name."
1897
		// http://www.w3.org/TR/selectors/#lang-pseudo
1898
		"lang": markFunction( function( lang ) {
1899
			// lang value must be a valid identifier
1900
			if ( !ridentifier.test(lang || "") ) {
1901
				Sizzle.error( "unsupported lang: " + lang );
1902
			}
1903
			lang = lang.replace( runescape, funescape ).toLowerCase();
1904
			return function( elem ) {
1905
				var elemLang;
1906
				do {
1907
					if ( (elemLang = documentIsHTML ?
1908
						elem.lang :
1909
						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
1910
1911
						elemLang = elemLang.toLowerCase();
1912
						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
1913
					}
1914
				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
1915
				return false;
1916
			};
1917
		}),
1918
1919
		// Miscellaneous
1920
		"target": function( elem ) {
1921
			var hash = window.location && window.location.hash;
1922
			return hash && hash.slice( 1 ) === elem.id;
1923
		},
1924
1925
		"root": function( elem ) {
1926
			return elem === docElem;
1927
		},
1928
1929
		"focus": function( elem ) {
1930
			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
1931
		},
1932
1933
		// Boolean properties
1934
		"enabled": function( elem ) {
1935
			return elem.disabled === false;
1936
		},
1937
1938
		"disabled": function( elem ) {
1939
			return elem.disabled === true;
1940
		},
1941
1942
		"checked": function( elem ) {
1943
			// In CSS3, :checked should return both checked and selected elements
1944
			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1945
			var nodeName = elem.nodeName.toLowerCase();
1946
			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
1947
		},
1948
1949
		"selected": function( elem ) {
1950
			// Accessing this property makes selected-by-default
1951
			// options in Safari work properly
1952
			if ( elem.parentNode ) {
1953
				elem.parentNode.selectedIndex;
1954
			}
1955
1956
			return elem.selected === true;
1957
		},
1958
1959
		// Contents
1960
		"empty": function( elem ) {
1961
			// http://www.w3.org/TR/selectors/#empty-pseudo
1962
			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
1963
			//   but not by others (comment: 8; processing instruction: 7; etc.)
1964
			// nodeType < 6 works because attributes (2) do not appear as children
1965
			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1966
				if ( elem.nodeType < 6 ) {
1967
					return false;
1968
				}
1969
			}
1970
			return true;
1971
		},
1972
1973
		"parent": function( elem ) {
1974
			return !Expr.pseudos["empty"]( elem );
1975
		},
1976
1977
		// Element/input types
1978
		"header": function( elem ) {
1979
			return rheader.test( elem.nodeName );
1980
		},
1981
1982
		"input": function( elem ) {
1983
			return rinputs.test( elem.nodeName );
1984
		},
1985
1986
		"button": function( elem ) {
1987
			var name = elem.nodeName.toLowerCase();
1988
			return name === "input" && elem.type === "button" || name === "button";
1989
		},
1990
1991
		"text": function( elem ) {
1992
			var attr;
1993
			return elem.nodeName.toLowerCase() === "input" &&
1994
				elem.type === "text" &&
1995
1996
				// Support: IE<8
1997
				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
1998
				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
1999
		},
2000
2001
		// Position-in-collection
2002
		"first": createPositionalPseudo(function() {
2003
			return [ 0 ];
2004
		}),
2005
2006
		"last": createPositionalPseudo(function( matchIndexes, length ) {
2007
			return [ length - 1 ];
2008
		}),
2009
2010
		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
2011
			return [ argument < 0 ? argument + length : argument ];
2012
		}),
2013
2014
		"even": createPositionalPseudo(function( matchIndexes, length ) {
2015
			var i = 0;
2016
			for ( ; i < length; i += 2 ) {
2017
				matchIndexes.push( i );
2018
			}
2019
			return matchIndexes;
2020
		}),
2021
2022
		"odd": createPositionalPseudo(function( matchIndexes, length ) {
2023
			var i = 1;
2024
			for ( ; i < length; i += 2 ) {
2025
				matchIndexes.push( i );
2026
			}
2027
			return matchIndexes;
2028
		}),
2029
2030
		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2031
			var i = argument < 0 ? argument + length : argument;
2032
			for ( ; --i >= 0; ) {
2033
				matchIndexes.push( i );
2034
			}
2035
			return matchIndexes;
2036
		}),
2037
2038
		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2039
			var i = argument < 0 ? argument + length : argument;
2040
			for ( ; ++i < length; ) {
2041
				matchIndexes.push( i );
2042
			}
2043
			return matchIndexes;
2044
		})
2045
	}
2046
};
2047
2048
Expr.pseudos["nth"] = Expr.pseudos["eq"];
2049
2050
// Add button/input type pseudos
2051
for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2052
	Expr.pseudos[ i ] = createInputPseudo( i );
2053
}
2054
for ( i in { submit: true, reset: true } ) {
2055
	Expr.pseudos[ i ] = createButtonPseudo( i );
2056
}
2057
2058
// Easy API for creating new setFilters
2059
function setFilters() {}
2060
setFilters.prototype = Expr.filters = Expr.pseudos;
2061
Expr.setFilters = new setFilters();
2062
2063
tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2064
	var matched, match, tokens, type,
2065
		soFar, groups, preFilters,
2066
		cached = tokenCache[ selector + " " ];
2067
2068
	if ( cached ) {
2069
		return parseOnly ? 0 : cached.slice( 0 );
2070
	}
2071
2072
	soFar = selector;
2073
	groups = [];
2074
	preFilters = Expr.preFilter;
2075
2076
	while ( soFar ) {
2077
2078
		// Comma and first run
2079
		if ( !matched || (match = rcomma.exec( soFar )) ) {
2080
			if ( match ) {
2081
				// Don't consume trailing commas as valid
2082
				soFar = soFar.slice( match[0].length ) || soFar;
2083
			}
2084
			groups.push( (tokens = []) );
2085
		}
2086
2087
		matched = false;
2088
2089
		// Combinators
2090
		if ( (match = rcombinators.exec( soFar )) ) {
2091
			matched = match.shift();
2092
			tokens.push({
2093
				value: matched,
2094
				// Cast descendant combinators to space
2095
				type: match[0].replace( rtrim, " " )
2096
			});
2097
			soFar = soFar.slice( matched.length );
2098
		}
2099
2100
		// Filters
2101
		for ( type in Expr.filter ) {
2102
			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2103
				(match = preFilters[ type ]( match ))) ) {
2104
				matched = match.shift();
2105
				tokens.push({
2106
					value: matched,
2107
					type: type,
2108
					matches: match
2109
				});
2110
				soFar = soFar.slice( matched.length );
2111
			}
2112
		}
2113
2114
		if ( !matched ) {
2115
			break;
2116
		}
2117
	}
2118
2119
	// Return the length of the invalid excess
2120
	// if we're just parsing
2121
	// Otherwise, throw an error or return tokens
2122
	return parseOnly ?
2123
		soFar.length :
2124
		soFar ?
2125
			Sizzle.error( selector ) :
2126
			// Cache the tokens
2127
			tokenCache( selector, groups ).slice( 0 );
2128
};
2129
2130
function toSelector( tokens ) {
2131
	var i = 0,
2132
		len = tokens.length,
2133
		selector = "";
2134
	for ( ; i < len; i++ ) {
2135
		selector += tokens[i].value;
2136
	}
2137
	return selector;
2138
}
2139
2140
function addCombinator( matcher, combinator, base ) {
2141
	var dir = combinator.dir,
2142
		checkNonElements = base && dir === "parentNode",
2143
		doneName = done++;
2144
2145
	return combinator.first ?
2146
		// Check against closest ancestor/preceding element
2147
		function( elem, context, xml ) {
2148
			while ( (elem = elem[ dir ]) ) {
2149
				if ( elem.nodeType === 1 || checkNonElements ) {
2150
					return matcher( elem, context, xml );
2151
				}
2152
			}
2153
		} :
2154
2155
		// Check against all ancestor/preceding elements
2156
		function( elem, context, xml ) {
2157
			var oldCache, uniqueCache, outerCache,
2158
				newCache = [ dirruns, doneName ];
2159
2160
			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2161
			if ( xml ) {
2162
				while ( (elem = elem[ dir ]) ) {
2163
					if ( elem.nodeType === 1 || checkNonElements ) {
2164
						if ( matcher( elem, context, xml ) ) {
2165
							return true;
2166
						}
2167
					}
2168
				}
2169
			} else {
2170
				while ( (elem = elem[ dir ]) ) {
2171
					if ( elem.nodeType === 1 || checkNonElements ) {
2172
						outerCache = elem[ expando ] || (elem[ expando ] = {});
2173
2174
						// Support: IE <9 only
2175
						// Defend against cloned attroperties (jQuery gh-1709)
2176
						uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
2177
2178
						if ( (oldCache = uniqueCache[ dir ]) &&
2179
							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2180
2181
							// Assign to newCache so results back-propagate to previous elements
2182
							return (newCache[ 2 ] = oldCache[ 2 ]);
2183
						} else {
2184
							// Reuse newcache so results back-propagate to previous elements
2185
							uniqueCache[ dir ] = newCache;
2186
2187
							// A match means we're done; a fail means we have to keep checking
2188
							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2189
								return true;
2190
							}
2191
						}
2192
					}
2193
				}
2194
			}
2195
		};
2196
}
2197
2198
function elementMatcher( matchers ) {
2199
	return matchers.length > 1 ?
2200
		function( elem, context, xml ) {
2201
			var i = matchers.length;
2202
			while ( i-- ) {
2203
				if ( !matchers[i]( elem, context, xml ) ) {
2204
					return false;
2205
				}
2206
			}
2207
			return true;
2208
		} :
2209
		matchers[0];
2210
}
2211
2212
function multipleContexts( selector, contexts, results ) {
2213
	var i = 0,
2214
		len = contexts.length;
2215
	for ( ; i < len; i++ ) {
2216
		Sizzle( selector, contexts[i], results );
2217
	}
2218
	return results;
2219
}
2220
2221
function condense( unmatched, map, filter, context, xml ) {
2222
	var elem,
2223
		newUnmatched = [],
2224
		i = 0,
2225
		len = unmatched.length,
2226
		mapped = map != null;
2227
2228
	for ( ; i < len; i++ ) {
2229
		if ( (elem = unmatched[i]) ) {
2230
			if ( !filter || filter( elem, context, xml ) ) {
2231
				newUnmatched.push( elem );
2232
				if ( mapped ) {
2233
					map.push( i );
2234
				}
2235
			}
2236
		}
2237
	}
2238
2239
	return newUnmatched;
2240
}
2241
2242
function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2243
	if ( postFilter && !postFilter[ expando ] ) {
2244
		postFilter = setMatcher( postFilter );
2245
	}
2246
	if ( postFinder && !postFinder[ expando ] ) {
2247
		postFinder = setMatcher( postFinder, postSelector );
2248
	}
2249
	return markFunction(function( seed, results, context, xml ) {
2250
		var temp, i, elem,
2251
			preMap = [],
2252
			postMap = [],
2253
			preexisting = results.length,
2254
2255
			// Get initial elements from seed or context
2256
			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2257
2258
			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2259
			matcherIn = preFilter && ( seed || !selector ) ?
2260
				condense( elems, preMap, preFilter, context, xml ) :
2261
				elems,
2262
2263
			matcherOut = matcher ?
2264
				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2265
				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2266
2267
					// ...intermediate processing is necessary
2268
					[] :
2269
2270
					// ...otherwise use results directly
2271
					results :
2272
				matcherIn;
2273
2274
		// Find primary matches
2275
		if ( matcher ) {
2276
			matcher( matcherIn, matcherOut, context, xml );
2277
		}
2278
2279
		// Apply postFilter
2280
		if ( postFilter ) {
2281
			temp = condense( matcherOut, postMap );
2282
			postFilter( temp, [], context, xml );
2283
2284
			// Un-match failing elements by moving them back to matcherIn
2285
			i = temp.length;
2286
			while ( i-- ) {
2287
				if ( (elem = temp[i]) ) {
2288
					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2289
				}
2290
			}
2291
		}
2292
2293
		if ( seed ) {
2294
			if ( postFinder || preFilter ) {
2295
				if ( postFinder ) {
2296
					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2297
					temp = [];
2298
					i = matcherOut.length;
2299
					while ( i-- ) {
2300
						if ( (elem = matcherOut[i]) ) {
2301
							// Restore matcherIn since elem is not yet a final match
2302
							temp.push( (matcherIn[i] = elem) );
2303
						}
2304
					}
2305
					postFinder( null, (matcherOut = []), temp, xml );
2306
				}
2307
2308
				// Move matched elements from seed to results to keep them synchronized
2309
				i = matcherOut.length;
2310
				while ( i-- ) {
2311
					if ( (elem = matcherOut[i]) &&
2312
						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
2313
2314
						seed[temp] = !(results[temp] = elem);
2315
					}
2316
				}
2317
			}
2318
2319
		// Add elements to results, through postFinder if defined
2320
		} else {
2321
			matcherOut = condense(
2322
				matcherOut === results ?
2323
					matcherOut.splice( preexisting, matcherOut.length ) :
2324
					matcherOut
2325
			);
2326
			if ( postFinder ) {
2327
				postFinder( null, results, matcherOut, xml );
2328
			} else {
2329
				push.apply( results, matcherOut );
2330
			}
2331
		}
2332
	});
2333
}
2334
2335
function matcherFromTokens( tokens ) {
2336
	var checkContext, matcher, j,
2337
		len = tokens.length,
2338
		leadingRelative = Expr.relative[ tokens[0].type ],
2339
		implicitRelative = leadingRelative || Expr.relative[" "],
2340
		i = leadingRelative ? 1 : 0,
2341
2342
		// The foundational matcher ensures that elements are reachable from top-level context(s)
2343
		matchContext = addCombinator( function( elem ) {
2344
			return elem === checkContext;
2345
		}, implicitRelative, true ),
2346
		matchAnyContext = addCombinator( function( elem ) {
2347
			return indexOf( checkContext, elem ) > -1;
2348
		}, implicitRelative, true ),
2349
		matchers = [ function( elem, context, xml ) {
2350
			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2351
				(checkContext = context).nodeType ?
2352
					matchContext( elem, context, xml ) :
2353
					matchAnyContext( elem, context, xml ) );
2354
			// Avoid hanging onto element (issue #299)
2355
			checkContext = null;
2356
			return ret;
2357
		} ];
2358
2359
	for ( ; i < len; i++ ) {
2360
		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2361
			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2362
		} else {
2363
			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2364
2365
			// Return special upon seeing a positional matcher
2366
			if ( matcher[ expando ] ) {
2367
				// Find the next relative operator (if any) for proper handling
2368
				j = ++i;
2369
				for ( ; j < len; j++ ) {
2370
					if ( Expr.relative[ tokens[j].type ] ) {
2371
						break;
2372
					}
2373
				}
2374
				return setMatcher(
2375
					i > 1 && elementMatcher( matchers ),
2376
					i > 1 && toSelector(
2377
						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2378
						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2379
					).replace( rtrim, "$1" ),
2380
					matcher,
2381
					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2382
					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2383
					j < len && toSelector( tokens )
2384
				);
2385
			}
2386
			matchers.push( matcher );
2387
		}
2388
	}
2389
2390
	return elementMatcher( matchers );
2391
}
2392
2393
function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2394
	var bySet = setMatchers.length > 0,
2395
		byElement = elementMatchers.length > 0,
2396
		superMatcher = function( seed, context, xml, results, outermost ) {
2397
			var elem, j, matcher,
2398
				matchedCount = 0,
2399
				i = "0",
2400
				unmatched = seed && [],
2401
				setMatched = [],
2402
				contextBackup = outermostContext,
2403
				// We must always have either seed elements or outermost context
2404
				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2405
				// Use integer dirruns iff this is the outermost matcher
2406
				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2407
				len = elems.length;
2408
2409
			if ( outermost ) {
2410
				outermostContext = context === document || context || outermost;
2411
			}
2412
2413
			// Add elements passing elementMatchers directly to results
2414
			// Support: IE<9, Safari
2415
			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2416
			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2417
				if ( byElement && elem ) {
2418
					j = 0;
2419
					if ( !context && elem.ownerDocument !== document ) {
2420
						setDocument( elem );
2421
						xml = !documentIsHTML;
2422
					}
2423
					while ( (matcher = elementMatchers[j++]) ) {
2424
						if ( matcher( elem, context || document, xml) ) {
2425
							results.push( elem );
2426
							break;
2427
						}
2428
					}
2429
					if ( outermost ) {
2430
						dirruns = dirrunsUnique;
2431
					}
2432
				}
2433
2434
				// Track unmatched elements for set filters
2435
				if ( bySet ) {
2436
					// They will have gone through all possible matchers
2437
					if ( (elem = !matcher && elem) ) {
2438
						matchedCount--;
2439
					}
2440
2441
					// Lengthen the array for every element, matched or not
2442
					if ( seed ) {
2443
						unmatched.push( elem );
2444
					}
2445
				}
2446
			}
2447
2448
			// `i` is now the count of elements visited above, and adding it to `matchedCount`
2449
			// makes the latter nonnegative.
2450
			matchedCount += i;
2451
2452
			// Apply set filters to unmatched elements
2453
			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2454
			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2455
			// no element matchers and no seed.
2456
			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2457
			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2458
			// numerically zero.
2459
			if ( bySet && i !== matchedCount ) {
2460
				j = 0;
2461
				while ( (matcher = setMatchers[j++]) ) {
2462
					matcher( unmatched, setMatched, context, xml );
2463
				}
2464
2465
				if ( seed ) {
2466
					// Reintegrate element matches to eliminate the need for sorting
2467
					if ( matchedCount > 0 ) {
2468
						while ( i-- ) {
2469
							if ( !(unmatched[i] || setMatched[i]) ) {
2470
								setMatched[i] = pop.call( results );
2471
							}
2472
						}
2473
					}
2474
2475
					// Discard index placeholder values to get only actual matches
2476
					setMatched = condense( setMatched );
2477
				}
2478
2479
				// Add matches to results
2480
				push.apply( results, setMatched );
2481
2482
				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2483
				if ( outermost && !seed && setMatched.length > 0 &&
2484
					( matchedCount + setMatchers.length ) > 1 ) {
2485
2486
					Sizzle.uniqueSort( results );
2487
				}
2488
			}
2489
2490
			// Override manipulation of globals by nested matchers
2491
			if ( outermost ) {
2492
				dirruns = dirrunsUnique;
2493
				outermostContext = contextBackup;
2494
			}
2495
2496
			return unmatched;
2497
		};
2498
2499
	return bySet ?
2500
		markFunction( superMatcher ) :
2501
		superMatcher;
2502
}
2503
2504
compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2505
	var i,
2506
		setMatchers = [],
2507
		elementMatchers = [],
2508
		cached = compilerCache[ selector + " " ];
2509
2510
	if ( !cached ) {
2511
		// Generate a function of recursive functions that can be used to check each element
2512
		if ( !match ) {
2513
			match = tokenize( selector );
2514
		}
2515
		i = match.length;
2516
		while ( i-- ) {
2517
			cached = matcherFromTokens( match[i] );
2518
			if ( cached[ expando ] ) {
2519
				setMatchers.push( cached );
2520
			} else {
2521
				elementMatchers.push( cached );
2522
			}
2523
		}
2524
2525
		// Cache the compiled function
2526
		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2527
2528
		// Save selector and tokenization
2529
		cached.selector = selector;
2530
	}
2531
	return cached;
2532
};
2533
2534
/**
2535
 * A low-level selection function that works with Sizzle's compiled
2536
 *  selector functions
2537
 * @param {String|Function} selector A selector or a pre-compiled
2538
 *  selector function built with Sizzle.compile
2539
 * @param {Element} context
2540
 * @param {Array} [results]
2541
 * @param {Array} [seed] A set of elements to match against
2542
 */
2543
select = Sizzle.select = function( selector, context, results, seed ) {
2544
	var i, tokens, token, type, find,
2545
		compiled = typeof selector === "function" && selector,
2546
		match = !seed && tokenize( (selector = compiled.selector || selector) );
2547
2548
	results = results || [];
2549
2550
	// Try to minimize operations if there is only one selector in the list and no seed
2551
	// (the latter of which guarantees us context)
2552
	if ( match.length === 1 ) {
2553
2554
		// Reduce context if the leading compound selector is an ID
2555
		tokens = match[0] = match[0].slice( 0 );
2556
		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2557
				support.getById && context.nodeType === 9 && documentIsHTML &&
2558
				Expr.relative[ tokens[1].type ] ) {
2559
2560
			context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2561
			if ( !context ) {
2562
				return results;
2563
2564
			// Precompiled matchers will still verify ancestry, so step up a level
2565
			} else if ( compiled ) {
2566
				context = context.parentNode;
2567
			}
2568
2569
			selector = selector.slice( tokens.shift().value.length );
2570
		}
2571
2572
		// Fetch a seed set for right-to-left matching
2573
		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2574
		while ( i-- ) {
2575
			token = tokens[i];
2576
2577
			// Abort if we hit a combinator
2578
			if ( Expr.relative[ (type = token.type) ] ) {
2579
				break;
2580
			}
2581
			if ( (find = Expr.find[ type ]) ) {
2582
				// Search, expanding context for leading sibling combinators
2583
				if ( (seed = find(
2584
					token.matches[0].replace( runescape, funescape ),
2585
					rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
2586
				)) ) {
2587
2588
					// If seed is empty or no tokens remain, we can return early
2589
					tokens.splice( i, 1 );
2590
					selector = seed.length && toSelector( tokens );
2591
					if ( !selector ) {
2592
						push.apply( results, seed );
2593
						return results;
2594
					}
2595
2596
					break;
2597
				}
2598
			}
2599
		}
2600
	}
2601
2602
	// Compile and execute a filtering function if one is not provided
2603
	// Provide `match` to avoid retokenization if we modified the selector above
2604
	( compiled || compile( selector, match ) )(
2605
		seed,
2606
		context,
2607
		!documentIsHTML,
2608
		results,
2609
		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2610
	);
2611
	return results;
2612
};
2613
2614
// One-time assignments
2615
2616
// Sort stability
2617
support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2618
2619
// Support: Chrome 14-35+
2620
// Always assume duplicates if they aren't passed to the comparison function
2621
support.detectDuplicates = !!hasDuplicate;
2622
2623
// Initialize against the default document
2624
setDocument();
2625
2626
// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2627
// Detached nodes confoundingly follow *each other*
2628
support.sortDetached = assert(function( div1 ) {
2629
	// Should return 1, but returns 4 (following)
2630
	return div1.compareDocumentPosition( document.createElement("div") ) & 1;
2631
});
2632
2633
// Support: IE<8
2634
// Prevent attribute/property "interpolation"
2635
// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2636
if ( !assert(function( div ) {
2637
	div.innerHTML = "<a href='#'></a>";
2638
	return div.firstChild.getAttribute("href") === "#" ;
2639
}) ) {
2640
	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2641
		if ( !isXML ) {
2642
			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2643
		}
2644
	});
2645
}
2646
2647
// Support: IE<9
2648
// Use defaultValue in place of getAttribute("value")
2649
if ( !support.attributes || !assert(function( div ) {
2650
	div.innerHTML = "<input/>";
2651
	div.firstChild.setAttribute( "value", "" );
2652
	return div.firstChild.getAttribute( "value" ) === "";
2653
}) ) {
2654
	addHandle( "value", function( elem, name, isXML ) {
2655
		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2656
			return elem.defaultValue;
2657
		}
2658
	});
2659
}
2660
2661
// Support: IE<9
2662
// Use getAttributeNode to fetch booleans when getAttribute lies
2663
if ( !assert(function( div ) {
2664
	return div.getAttribute("disabled") == null;
2665
}) ) {
2666
	addHandle( booleans, function( elem, name, isXML ) {
2667
		var val;
2668
		if ( !isXML ) {
2669
			return elem[ name ] === true ? name.toLowerCase() :
2670
					(val = elem.getAttributeNode( name )) && val.specified ?
2671
					val.value :
2672
				null;
2673
		}
2674
	});
2675
}
2676
2677
return Sizzle;
2678
2679
})( window );
2680
2681
2682
2683
jQuery.find = Sizzle;
2684
jQuery.expr = Sizzle.selectors;
2685
jQuery.expr[ ":" ] = jQuery.expr.pseudos;
2686
jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2687
jQuery.text = Sizzle.getText;
2688
jQuery.isXMLDoc = Sizzle.isXML;
2689
jQuery.contains = Sizzle.contains;
2690
2691
2692
2693
var dir = function( elem, dir, until ) {
2694
	var matched = [],
2695
		truncate = until !== undefined;
2696
2697
	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
2698
		if ( elem.nodeType === 1 ) {
2699
			if ( truncate && jQuery( elem ).is( until ) ) {
2700
				break;
2701
			}
2702
			matched.push( elem );
2703
		}
2704
	}
2705
	return matched;
2706
};
2707
2708
2709
var siblings = function( n, elem ) {
2710
	var matched = [];
2711
2712
	for ( ; n; n = n.nextSibling ) {
2713
		if ( n.nodeType === 1 && n !== elem ) {
2714
			matched.push( n );
2715
		}
2716
	}
2717
2718
	return matched;
2719
};
2720
2721
2722
var rneedsContext = jQuery.expr.match.needsContext;
2723
2724
var rsingleTag = ( /^<([\w-]+)\s*\/?>(?:<\/\1>|)$/ );
2725
2726
2727
2728
var risSimple = /^.[^:#\[\.,]*$/;
2729
2730
// Implement the identical functionality for filter and not
2731
function winnow( elements, qualifier, not ) {
2732
	if ( jQuery.isFunction( qualifier ) ) {
2733
		return jQuery.grep( elements, function( elem, i ) {
2734
			/* jshint -W018 */
2735
			return !!qualifier.call( elem, i, elem ) !== not;
2736
		} );
2737
2738
	}
2739
2740
	if ( qualifier.nodeType ) {
2741
		return jQuery.grep( elements, function( elem ) {
2742
			return ( elem === qualifier ) !== not;
2743
		} );
2744
2745
	}
2746
2747
	if ( typeof qualifier === "string" ) {
2748
		if ( risSimple.test( qualifier ) ) {
2749
			return jQuery.filter( qualifier, elements, not );
2750
		}
2751
2752
		qualifier = jQuery.filter( qualifier, elements );
2753
	}
2754
2755
	return jQuery.grep( elements, function( elem ) {
2756
		return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
2757
	} );
2758
}
2759
2760
jQuery.filter = function( expr, elems, not ) {
2761
	var elem = elems[ 0 ];
2762
2763
	if ( not ) {
2764
		expr = ":not(" + expr + ")";
2765
	}
2766
2767
	return elems.length === 1 && elem.nodeType === 1 ?
2768
		jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
2769
		jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
2770
			return elem.nodeType === 1;
2771
		} ) );
2772
};
2773
2774
jQuery.fn.extend( {
2775
	find: function( selector ) {
2776
		var i,
2777
			len = this.length,
2778
			ret = [],
2779
			self = this;
2780
2781
		if ( typeof selector !== "string" ) {
2782
			return this.pushStack( jQuery( selector ).filter( function() {
2783
				for ( i = 0; i < len; i++ ) {
2784
					if ( jQuery.contains( self[ i ], this ) ) {
2785
						return true;
2786
					}
2787
				}
2788
			} ) );
2789
		}
2790
2791
		for ( i = 0; i < len; i++ ) {
2792
			jQuery.find( selector, self[ i ], ret );
2793
		}
2794
2795
		// Needed because $( selector, context ) becomes $( context ).find( selector )
2796
		ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
2797
		ret.selector = this.selector ? this.selector + " " + selector : selector;
2798
		return ret;
2799
	},
2800
	filter: function( selector ) {
2801
		return this.pushStack( winnow( this, selector || [], false ) );
2802
	},
2803
	not: function( selector ) {
2804
		return this.pushStack( winnow( this, selector || [], true ) );
2805
	},
2806
	is: function( selector ) {
2807
		return !!winnow(
2808
			this,
2809
2810
			// If this is a positional/relative selector, check membership in the returned set
2811
			// so $("p:first").is("p:last") won't return true for a doc with two "p".
2812
			typeof selector === "string" && rneedsContext.test( selector ) ?
2813
				jQuery( selector ) :
2814
				selector || [],
2815
			false
2816
		).length;
2817
	}
2818
} );
2819
2820
2821
// Initialize a jQuery object
2822
2823
2824
// A central reference to the root jQuery(document)
2825
var rootjQuery,
2826
2827
	// A simple way to check for HTML strings
2828
	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
2829
	// Strict HTML recognition (#11290: must start with <)
2830
	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
2831
2832
	init = jQuery.fn.init = function( selector, context, root ) {
2833
		var match, elem;
2834
2835
		// HANDLE: $(""), $(null), $(undefined), $(false)
2836
		if ( !selector ) {
2837
			return this;
2838
		}
2839
2840
		// Method init() accepts an alternate rootjQuery
2841
		// so migrate can support jQuery.sub (gh-2101)
2842
		root = root || rootjQuery;
2843
2844
		// Handle HTML strings
2845
		if ( typeof selector === "string" ) {
2846
			if ( selector[ 0 ] === "<" &&
2847
				selector[ selector.length - 1 ] === ">" &&
2848
				selector.length >= 3 ) {
2849
2850
				// Assume that strings that start and end with <> are HTML and skip the regex check
2851
				match = [ null, selector, null ];
2852
2853
			} else {
2854
				match = rquickExpr.exec( selector );
2855
			}
2856
2857
			// Match html or make sure no context is specified for #id
2858
			if ( match && ( match[ 1 ] || !context ) ) {
2859
2860
				// HANDLE: $(html) -> $(array)
2861
				if ( match[ 1 ] ) {
2862
					context = context instanceof jQuery ? context[ 0 ] : context;
2863
2864
					// Option to run scripts is true for back-compat
2865
					// Intentionally let the error be thrown if parseHTML is not present
2866
					jQuery.merge( this, jQuery.parseHTML(
2867
						match[ 1 ],
2868
						context && context.nodeType ? context.ownerDocument || context : document,
2869
						true
2870
					) );
2871
2872
					// HANDLE: $(html, props)
2873
					if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
2874
						for ( match in context ) {
2875
2876
							// Properties of context are called as methods if possible
2877
							if ( jQuery.isFunction( this[ match ] ) ) {
2878
								this[ match ]( context[ match ] );
2879
2880
							// ...and otherwise set as attributes
2881
							} else {
2882
								this.attr( match, context[ match ] );
2883
							}
2884
						}
2885
					}
2886
2887
					return this;
2888
2889
				// HANDLE: $(#id)
2890
				} else {
2891
					elem = document.getElementById( match[ 2 ] );
2892
2893
					// Support: Blackberry 4.6
2894
					// gEBID returns nodes no longer in the document (#6963)
2895
					if ( elem && elem.parentNode ) {
2896
2897
						// Inject the element directly into the jQuery object
2898
						this.length = 1;
2899
						this[ 0 ] = elem;
2900
					}
2901
2902
					this.context = document;
2903
					this.selector = selector;
2904
					return this;
2905
				}
2906
2907
			// HANDLE: $(expr, $(...))
2908
			} else if ( !context || context.jquery ) {
2909
				return ( context || root ).find( selector );
2910
2911
			// HANDLE: $(expr, context)
2912
			// (which is just equivalent to: $(context).find(expr)
2913
			} else {
2914
				return this.constructor( context ).find( selector );
2915
			}
2916
2917
		// HANDLE: $(DOMElement)
2918
		} else if ( selector.nodeType ) {
2919
			this.context = this[ 0 ] = selector;
2920
			this.length = 1;
2921
			return this;
2922
2923
		// HANDLE: $(function)
2924
		// Shortcut for document ready
2925
		} else if ( jQuery.isFunction( selector ) ) {
2926
			return root.ready !== undefined ?
2927
				root.ready( selector ) :
2928
2929
				// Execute immediately if ready is not present
2930
				selector( jQuery );
2931
		}
2932
2933
		if ( selector.selector !== undefined ) {
2934
			this.selector = selector.selector;
2935
			this.context = selector.context;
2936
		}
2937
2938
		return jQuery.makeArray( selector, this );
2939
	};
2940
2941
// Give the init function the jQuery prototype for later instantiation
2942
init.prototype = jQuery.fn;
2943
2944
// Initialize central reference
2945
rootjQuery = jQuery( document );
2946
2947
2948
var rparentsprev = /^(?:parents|prev(?:Until|All))/,
2949
2950
	// Methods guaranteed to produce a unique set when starting from a unique set
2951
	guaranteedUnique = {
2952
		children: true,
2953
		contents: true,
2954
		next: true,
2955
		prev: true
2956
	};
2957
2958
jQuery.fn.extend( {
2959
	has: function( target ) {
2960
		var targets = jQuery( target, this ),
2961
			l = targets.length;
2962
2963
		return this.filter( function() {
2964
			var i = 0;
2965
			for ( ; i < l; i++ ) {
2966
				if ( jQuery.contains( this, targets[ i ] ) ) {
2967
					return true;
2968
				}
2969
			}
2970
		} );
2971
	},
2972
2973
	closest: function( selectors, context ) {
2974
		var cur,
2975
			i = 0,
2976
			l = this.length,
2977
			matched = [],
2978
			pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
2979
				jQuery( selectors, context || this.context ) :
2980
				0;
2981
2982
		for ( ; i < l; i++ ) {
2983
			for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
2984
2985
				// Always skip document fragments
2986
				if ( cur.nodeType < 11 && ( pos ?
2987
					pos.index( cur ) > -1 :
2988
2989
					// Don't pass non-elements to Sizzle
2990
					cur.nodeType === 1 &&
2991
						jQuery.find.matchesSelector( cur, selectors ) ) ) {
2992
2993
					matched.push( cur );
2994
					break;
2995
				}
2996
			}
2997
		}
2998
2999
		return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
3000
	},
3001
3002
	// Determine the position of an element within the set
3003
	index: function( elem ) {
3004
3005
		// No argument, return index in parent
3006
		if ( !elem ) {
3007
			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
3008
		}
3009
3010
		// Index in selector
3011
		if ( typeof elem === "string" ) {
3012
			return indexOf.call( jQuery( elem ), this[ 0 ] );
3013
		}
3014
3015
		// Locate the position of the desired element
3016
		return indexOf.call( this,
3017
3018
			// If it receives a jQuery object, the first element is used
3019
			elem.jquery ? elem[ 0 ] : elem
3020
		);
3021
	},
3022
3023
	add: function( selector, context ) {
3024
		return this.pushStack(
3025
			jQuery.uniqueSort(
3026
				jQuery.merge( this.get(), jQuery( selector, context ) )
3027
			)
3028
		);
3029
	},
3030
3031
	addBack: function( selector ) {
3032
		return this.add( selector == null ?
3033
			this.prevObject : this.prevObject.filter( selector )
3034
		);
3035
	}
3036
} );
3037
3038
function sibling( cur, dir ) {
3039
	while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
3040
	return cur;
3041
}
3042
3043
jQuery.each( {
3044
	parent: function( elem ) {
3045
		var parent = elem.parentNode;
3046
		return parent && parent.nodeType !== 11 ? parent : null;
3047
	},
3048
	parents: function( elem ) {
3049
		return dir( elem, "parentNode" );
3050
	},
3051
	parentsUntil: function( elem, i, until ) {
3052
		return dir( elem, "parentNode", until );
3053
	},
3054
	next: function( elem ) {
3055
		return sibling( elem, "nextSibling" );
3056
	},
3057
	prev: function( elem ) {
3058
		return sibling( elem, "previousSibling" );
3059
	},
3060
	nextAll: function( elem ) {
3061
		return dir( elem, "nextSibling" );
3062
	},
3063
	prevAll: function( elem ) {
3064
		return dir( elem, "previousSibling" );
3065
	},
3066
	nextUntil: function( elem, i, until ) {
3067
		return dir( elem, "nextSibling", until );
3068
	},
3069
	prevUntil: function( elem, i, until ) {
3070
		return dir( elem, "previousSibling", until );
3071
	},
3072
	siblings: function( elem ) {
3073
		return siblings( ( elem.parentNode || {} ).firstChild, elem );
3074
	},
3075
	children: function( elem ) {
3076
		return siblings( elem.firstChild );
3077
	},
3078
	contents: function( elem ) {
3079
		return elem.contentDocument || jQuery.merge( [], elem.childNodes );
3080
	}
3081
}, function( name, fn ) {
3082
	jQuery.fn[ name ] = function( until, selector ) {
3083
		var matched = jQuery.map( this, fn, until );
3084
3085
		if ( name.slice( -5 ) !== "Until" ) {
3086
			selector = until;
3087
		}
3088
3089
		if ( selector && typeof selector === "string" ) {
3090
			matched = jQuery.filter( selector, matched );
3091
		}
3092
3093
		if ( this.length > 1 ) {
3094
3095
			// Remove duplicates
3096
			if ( !guaranteedUnique[ name ] ) {
3097
				jQuery.uniqueSort( matched );
3098
			}
3099
3100
			// Reverse order for parents* and prev-derivatives
3101
			if ( rparentsprev.test( name ) ) {
3102
				matched.reverse();
3103
			}
3104
		}
3105
3106
		return this.pushStack( matched );
3107
	};
3108
} );
3109
var rnotwhite = ( /\S+/g );
3110
3111
3112
3113
// Convert String-formatted options into Object-formatted ones
3114
function createOptions( options ) {
3115
	var object = {};
3116
	jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
3117
		object[ flag ] = true;
3118
	} );
3119
	return object;
3120
}
3121
3122
/*
3123
 * Create a callback list using the following parameters:
3124
 *
3125
 *	options: an optional list of space-separated options that will change how
3126
 *			the callback list behaves or a more traditional option object
3127
 *
3128
 * By default a callback list will act like an event callback list and can be
3129
 * "fired" multiple times.
3130
 *
3131
 * Possible options:
3132
 *
3133
 *	once:			will ensure the callback list can only be fired once (like a Deferred)
3134
 *
3135
 *	memory:			will keep track of previous values and will call any callback added
3136
 *					after the list has been fired right away with the latest "memorized"
3137
 *					values (like a Deferred)
3138
 *
3139
 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
3140
 *
3141
 *	stopOnFalse:	interrupt callings when a callback returns false
3142
 *
3143
 */
3144
jQuery.Callbacks = function( options ) {
3145
3146
	// Convert options from String-formatted to Object-formatted if needed
3147
	// (we check in cache first)
3148
	options = typeof options === "string" ?
3149
		createOptions( options ) :
3150
		jQuery.extend( {}, options );
3151
3152
	var // Flag to know if list is currently firing
3153
		firing,
3154
3155
		// Last fire value for non-forgettable lists
3156
		memory,
3157
3158
		// Flag to know if list was already fired
3159
		fired,
3160
3161
		// Flag to prevent firing
3162
		locked,
3163
3164
		// Actual callback list
3165
		list = [],
3166
3167
		// Queue of execution data for repeatable lists
3168
		queue = [],
3169
3170
		// Index of currently firing callback (modified by add/remove as needed)
3171
		firingIndex = -1,
3172
3173
		// Fire callbacks
3174
		fire = function() {
3175
3176
			// Enforce single-firing
3177
			locked = options.once;
3178
3179
			// Execute callbacks for all pending executions,
3180
			// respecting firingIndex overrides and runtime changes
3181
			fired = firing = true;
3182
			for ( ; queue.length; firingIndex = -1 ) {
3183
				memory = queue.shift();
3184
				while ( ++firingIndex < list.length ) {
3185
3186
					// Run callback and check for early termination
3187
					if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
3188
						options.stopOnFalse ) {
3189
3190
						// Jump to end and forget the data so .add doesn't re-fire
3191
						firingIndex = list.length;
3192
						memory = false;
3193
					}
3194
				}
3195
			}
3196
3197
			// Forget the data if we're done with it
3198
			if ( !options.memory ) {
3199
				memory = false;
3200
			}
3201
3202
			firing = false;
3203
3204
			// Clean up if we're done firing for good
3205
			if ( locked ) {
3206
3207
				// Keep an empty list if we have data for future add calls
3208
				if ( memory ) {
3209
					list = [];
3210
3211
				// Otherwise, this object is spent
3212
				} else {
3213
					list = "";
3214
				}
3215
			}
3216
		},
3217
3218
		// Actual Callbacks object
3219
		self = {
3220
3221
			// Add a callback or a collection of callbacks to the list
3222
			add: function() {
3223
				if ( list ) {
3224
3225
					// If we have memory from a past run, we should fire after adding
3226
					if ( memory && !firing ) {
3227
						firingIndex = list.length - 1;
3228
						queue.push( memory );
3229
					}
3230
3231
					( function add( args ) {
3232
						jQuery.each( args, function( _, arg ) {
3233
							if ( jQuery.isFunction( arg ) ) {
3234
								if ( !options.unique || !self.has( arg ) ) {
3235
									list.push( arg );
3236
								}
3237
							} else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) {
3238
3239
								// Inspect recursively
3240
								add( arg );
3241
							}
3242
						} );
3243
					} )( arguments );
3244
3245
					if ( memory && !firing ) {
3246
						fire();
3247
					}
3248
				}
3249
				return this;
3250
			},
3251
3252
			// Remove a callback from the list
3253
			remove: function() {
3254
				jQuery.each( arguments, function( _, arg ) {
3255
					var index;
3256
					while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
3257
						list.splice( index, 1 );
3258
3259
						// Handle firing indexes
3260
						if ( index <= firingIndex ) {
3261
							firingIndex--;
3262
						}
3263
					}
3264
				} );
3265
				return this;
3266
			},
3267
3268
			// Check if a given callback is in the list.
3269
			// If no argument is given, return whether or not list has callbacks attached.
3270
			has: function( fn ) {
3271
				return fn ?
3272
					jQuery.inArray( fn, list ) > -1 :
3273
					list.length > 0;
3274
			},
3275
3276
			// Remove all callbacks from the list
3277
			empty: function() {
3278
				if ( list ) {
3279
					list = [];
3280
				}
3281
				return this;
3282
			},
3283
3284
			// Disable .fire and .add
3285
			// Abort any current/pending executions
3286
			// Clear all callbacks and values
3287
			disable: function() {
3288
				locked = queue = [];
3289
				list = memory = "";
3290
				return this;
3291
			},
3292
			disabled: function() {
3293
				return !list;
3294
			},
3295
3296
			// Disable .fire
3297
			// Also disable .add unless we have memory (since it would have no effect)
3298
			// Abort any pending executions
3299
			lock: function() {
3300
				locked = queue = [];
3301
				if ( !memory ) {
3302
					list = memory = "";
3303
				}
3304
				return this;
3305
			},
3306
			locked: function() {
3307
				return !!locked;
3308
			},
3309
3310
			// Call all callbacks with the given context and arguments
3311
			fireWith: function( context, args ) {
3312
				if ( !locked ) {
3313
					args = args || [];
3314
					args = [ context, args.slice ? args.slice() : args ];
3315
					queue.push( args );
3316
					if ( !firing ) {
3317
						fire();
3318
					}
3319
				}
3320
				return this;
3321
			},
3322
3323
			// Call all the callbacks with the given arguments
3324
			fire: function() {
3325
				self.fireWith( this, arguments );
3326
				return this;
3327
			},
3328
3329
			// To know if the callbacks have already been called at least once
3330
			fired: function() {
3331
				return !!fired;
3332
			}
3333
		};
3334
3335
	return self;
3336
};
3337
3338
3339
jQuery.extend( {
3340
3341
	Deferred: function( func ) {
3342
		var tuples = [
3343
3344
				// action, add listener, listener list, final state
3345
				[ "resolve", "done", jQuery.Callbacks( "once memory" ), "resolved" ],
3346
				[ "reject", "fail", jQuery.Callbacks( "once memory" ), "rejected" ],
3347
				[ "notify", "progress", jQuery.Callbacks( "memory" ) ]
3348
			],
3349
			state = "pending",
3350
			promise = {
3351
				state: function() {
3352
					return state;
3353
				},
3354
				always: function() {
3355
					deferred.done( arguments ).fail( arguments );
3356
					return this;
3357
				},
3358
				then: function( /* fnDone, fnFail, fnProgress */ ) {
3359
					var fns = arguments;
3360
					return jQuery.Deferred( function( newDefer ) {
3361
						jQuery.each( tuples, function( i, tuple ) {
3362
							var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
3363
3364
							// deferred[ done | fail | progress ] for forwarding actions to newDefer
3365
							deferred[ tuple[ 1 ] ]( function() {
3366
								var returned = fn && fn.apply( this, arguments );
3367
								if ( returned && jQuery.isFunction( returned.promise ) ) {
3368
									returned.promise()
3369
										.progress( newDefer.notify )
3370
										.done( newDefer.resolve )
3371
										.fail( newDefer.reject );
3372
								} else {
3373
									newDefer[ tuple[ 0 ] + "With" ](
3374
										this === promise ? newDefer.promise() : this,
3375
										fn ? [ returned ] : arguments
3376
									);
3377
								}
3378
							} );
3379
						} );
3380
						fns = null;
3381
					} ).promise();
3382
				},
3383
3384
				// Get a promise for this deferred
3385
				// If obj is provided, the promise aspect is added to the object
3386
				promise: function( obj ) {
3387
					return obj != null ? jQuery.extend( obj, promise ) : promise;
3388
				}
3389
			},
3390
			deferred = {};
3391
3392
		// Keep pipe for back-compat
3393
		promise.pipe = promise.then;
3394
3395
		// Add list-specific methods
3396
		jQuery.each( tuples, function( i, tuple ) {
3397
			var list = tuple[ 2 ],
3398
				stateString = tuple[ 3 ];
3399
3400
			// promise[ done | fail | progress ] = list.add
3401
			promise[ tuple[ 1 ] ] = list.add;
3402
3403
			// Handle state
3404
			if ( stateString ) {
3405
				list.add( function() {
3406
3407
					// state = [ resolved | rejected ]
3408
					state = stateString;
3409
3410
				// [ reject_list | resolve_list ].disable; progress_list.lock
3411
				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
3412
			}
3413
3414
			// deferred[ resolve | reject | notify ]
3415
			deferred[ tuple[ 0 ] ] = function() {
3416
				deferred[ tuple[ 0 ] + "With" ]( this === deferred ? promise : this, arguments );
3417
				return this;
3418
			};
3419
			deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
3420
		} );
3421
3422
		// Make the deferred a promise
3423
		promise.promise( deferred );
3424
3425
		// Call given func if any
3426
		if ( func ) {
3427
			func.call( deferred, deferred );
3428
		}
3429
3430
		// All done!
3431
		return deferred;
3432
	},
3433
3434
	// Deferred helper
3435
	when: function( subordinate /* , ..., subordinateN */ ) {
3436
		var i = 0,
3437
			resolveValues = slice.call( arguments ),
3438
			length = resolveValues.length,
3439
3440
			// the count of uncompleted subordinates
3441
			remaining = length !== 1 ||
3442
				( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
3443
3444
			// the master Deferred.
3445
			// If resolveValues consist of only a single Deferred, just use that.
3446
			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
3447
3448
			// Update function for both resolve and progress values
3449
			updateFunc = function( i, contexts, values ) {
3450
				return function( value ) {
3451
					contexts[ i ] = this;
3452
					values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
3453
					if ( values === progressValues ) {
3454
						deferred.notifyWith( contexts, values );
3455
					} else if ( !( --remaining ) ) {
3456
						deferred.resolveWith( contexts, values );
3457
					}
3458
				};
3459
			},
3460
3461
			progressValues, progressContexts, resolveContexts;
3462
3463
		// Add listeners to Deferred subordinates; treat others as resolved
3464
		if ( length > 1 ) {
3465
			progressValues = new Array( length );
3466
			progressContexts = new Array( length );
3467
			resolveContexts = new Array( length );
3468
			for ( ; i < length; i++ ) {
3469
				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
3470
					resolveValues[ i ].promise()
3471
						.progress( updateFunc( i, progressContexts, progressValues ) )
3472
						.done( updateFunc( i, resolveContexts, resolveValues ) )
3473
						.fail( deferred.reject );
3474
				} else {
3475
					--remaining;
3476
				}
3477
			}
3478
		}
3479
3480
		// If we're not waiting on anything, resolve the master
3481
		if ( !remaining ) {
3482
			deferred.resolveWith( resolveContexts, resolveValues );
3483
		}
3484
3485
		return deferred.promise();
3486
	}
3487
} );
3488
3489
3490
// The deferred used on DOM ready
3491
var readyList;
3492
3493
jQuery.fn.ready = function( fn ) {
3494
3495
	// Add the callback
3496
	jQuery.ready.promise().done( fn );
3497
3498
	return this;
3499
};
3500
3501
jQuery.extend( {
3502
3503
	// Is the DOM ready to be used? Set to true once it occurs.
3504
	isReady: false,
3505
3506
	// A counter to track how many items to wait for before
3507
	// the ready event fires. See #6781
3508
	readyWait: 1,
3509
3510
	// Hold (or release) the ready event
3511
	holdReady: function( hold ) {
3512
		if ( hold ) {
3513
			jQuery.readyWait++;
3514
		} else {
3515
			jQuery.ready( true );
3516
		}
3517
	},
3518
3519
	// Handle when the DOM is ready
3520
	ready: function( wait ) {
3521
3522
		// Abort if there are pending holds or we're already ready
3523
		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
3524
			return;
3525
		}
3526
3527
		// Remember that the DOM is ready
3528
		jQuery.isReady = true;
3529
3530
		// If a normal DOM Ready event fired, decrement, and wait if need be
3531
		if ( wait !== true && --jQuery.readyWait > 0 ) {
3532
			return;
3533
		}
3534
3535
		// If there are functions bound, to execute
3536
		readyList.resolveWith( document, [ jQuery ] );
3537
3538
		// Trigger any bound ready events
3539
		if ( jQuery.fn.triggerHandler ) {
3540
			jQuery( document ).triggerHandler( "ready" );
3541
			jQuery( document ).off( "ready" );
3542
		}
3543
	}
3544
} );
3545
3546
/**
3547
 * The ready event handler and self cleanup method
3548
 */
3549
function completed() {
3550
	document.removeEventListener( "DOMContentLoaded", completed );
3551
	window.removeEventListener( "load", completed );
3552
	jQuery.ready();
3553
}
3554
3555
jQuery.ready.promise = function( obj ) {
3556
	if ( !readyList ) {
3557
3558
		readyList = jQuery.Deferred();
3559
3560
		// Catch cases where $(document).ready() is called
3561
		// after the browser event has already occurred.
3562
		// Support: IE9-10 only
3563
		// Older IE sometimes signals "interactive" too soon
3564
		if ( document.readyState === "complete" ||
3565
			( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
3566
3567
			// Handle it asynchronously to allow scripts the opportunity to delay ready
3568
			window.setTimeout( jQuery.ready );
3569
3570
		} else {
3571
3572
			// Use the handy event callback
3573
			document.addEventListener( "DOMContentLoaded", completed );
3574
3575
			// A fallback to window.onload, that will always work
3576
			window.addEventListener( "load", completed );
3577
		}
3578
	}
3579
	return readyList.promise( obj );
3580
};
3581
3582
// Kick off the DOM ready check even if the user does not
3583
jQuery.ready.promise();
3584
3585
3586
3587
3588
// Multifunctional method to get and set values of a collection
3589
// The value/s can optionally be executed if it's a function
3590
var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
3591
	var i = 0,
3592
		len = elems.length,
3593
		bulk = key == null;
3594
3595
	// Sets many values
3596
	if ( jQuery.type( key ) === "object" ) {
3597
		chainable = true;
3598
		for ( i in key ) {
3599
			access( elems, fn, i, key[ i ], true, emptyGet, raw );
3600
		}
3601
3602
	// Sets one value
3603
	} else if ( value !== undefined ) {
3604
		chainable = true;
3605
3606
		if ( !jQuery.isFunction( value ) ) {
3607
			raw = true;
3608
		}
3609
3610
		if ( bulk ) {
3611
3612
			// Bulk operations run against the entire set
3613
			if ( raw ) {
3614
				fn.call( elems, value );
3615
				fn = null;
3616
3617
			// ...except when executing function values
3618
			} else {
3619
				bulk = fn;
3620
				fn = function( elem, key, value ) {
3621
					return bulk.call( jQuery( elem ), value );
3622
				};
3623
			}
3624
		}
3625
3626
		if ( fn ) {
3627
			for ( ; i < len; i++ ) {
3628
				fn(
3629
					elems[ i ], key, raw ?
3630
					value :
3631
					value.call( elems[ i ], i, fn( elems[ i ], key ) )
3632
				);
3633
			}
3634
		}
3635
	}
3636
3637
	return chainable ?
3638
		elems :
3639
3640
		// Gets
3641
		bulk ?
3642
			fn.call( elems ) :
3643
			len ? fn( elems[ 0 ], key ) : emptyGet;
3644
};
3645
var acceptData = function( owner ) {
3646
3647
	// Accepts only:
3648
	//  - Node
3649
	//    - Node.ELEMENT_NODE
3650
	//    - Node.DOCUMENT_NODE
3651
	//  - Object
3652
	//    - Any
3653
	/* jshint -W018 */
3654
	return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
3655
};
3656
3657
3658
3659
3660
function Data() {
3661
	this.expando = jQuery.expando + Data.uid++;
3662
}
3663
3664
Data.uid = 1;
3665
3666
Data.prototype = {
3667
3668
	register: function( owner, initial ) {
3669
		var value = initial || {};
3670
3671
		// If it is a node unlikely to be stringify-ed or looped over
3672
		// use plain assignment
3673
		if ( owner.nodeType ) {
3674
			owner[ this.expando ] = value;
3675
3676
		// Otherwise secure it in a non-enumerable, non-writable property
3677
		// configurability must be true to allow the property to be
3678
		// deleted with the delete operator
3679
		} else {
3680
			Object.defineProperty( owner, this.expando, {
3681
				value: value,
3682
				writable: true,
3683
				configurable: true
3684
			} );
3685
		}
3686
		return owner[ this.expando ];
3687
	},
3688
	cache: function( owner ) {
3689
3690
		// We can accept data for non-element nodes in modern browsers,
3691
		// but we should not, see #8335.
3692
		// Always return an empty object.
3693
		if ( !acceptData( owner ) ) {
3694
			return {};
3695
		}
3696
3697
		// Check if the owner object already has a cache
3698
		var value = owner[ this.expando ];
3699
3700
		// If not, create one
3701
		if ( !value ) {
3702
			value = {};
3703
3704
			// We can accept data for non-element nodes in modern browsers,
3705
			// but we should not, see #8335.
3706
			// Always return an empty object.
3707
			if ( acceptData( owner ) ) {
3708
3709
				// If it is a node unlikely to be stringify-ed or looped over
3710
				// use plain assignment
3711
				if ( owner.nodeType ) {
3712
					owner[ this.expando ] = value;
3713
3714
				// Otherwise secure it in a non-enumerable property
3715
				// configurable must be true to allow the property to be
3716
				// deleted when data is removed
3717
				} else {
3718
					Object.defineProperty( owner, this.expando, {
3719
						value: value,
3720
						configurable: true
3721
					} );
3722
				}
3723
			}
3724
		}
3725
3726
		return value;
3727
	},
3728
	set: function( owner, data, value ) {
3729
		var prop,
3730
			cache = this.cache( owner );
3731
3732
		// Handle: [ owner, key, value ] args
3733
		if ( typeof data === "string" ) {
3734
			cache[ data ] = value;
3735
3736
		// Handle: [ owner, { properties } ] args
3737
		} else {
3738
3739
			// Copy the properties one-by-one to the cache object
3740
			for ( prop in data ) {
3741
				cache[ prop ] = data[ prop ];
3742
			}
3743
		}
3744
		return cache;
3745
	},
3746
	get: function( owner, key ) {
3747
		return key === undefined ?
3748
			this.cache( owner ) :
3749
			owner[ this.expando ] && owner[ this.expando ][ key ];
3750
	},
3751
	access: function( owner, key, value ) {
3752
		var stored;
3753
3754
		// In cases where either:
3755
		//
3756
		//   1. No key was specified
3757
		//   2. A string key was specified, but no value provided
3758
		//
3759
		// Take the "read" path and allow the get method to determine
3760
		// which value to return, respectively either:
3761
		//
3762
		//   1. The entire cache object
3763
		//   2. The data stored at the key
3764
		//
3765
		if ( key === undefined ||
3766
				( ( key && typeof key === "string" ) && value === undefined ) ) {
3767
3768
			stored = this.get( owner, key );
3769
3770
			return stored !== undefined ?
3771
				stored : this.get( owner, jQuery.camelCase( key ) );
3772
		}
3773
3774
		// When the key is not a string, or both a key and value
3775
		// are specified, set or extend (existing objects) with either:
3776
		//
3777
		//   1. An object of properties
3778
		//   2. A key and value
3779
		//
3780
		this.set( owner, key, value );
3781
3782
		// Since the "set" path can have two possible entry points
3783
		// return the expected data based on which path was taken[*]
3784
		return value !== undefined ? value : key;
3785
	},
3786
	remove: function( owner, key ) {
3787
		var i, name, camel,
3788
			cache = owner[ this.expando ];
3789
3790
		if ( cache === undefined ) {
3791
			return;
3792
		}
3793
3794
		if ( key === undefined ) {
3795
			this.register( owner );
3796
3797
		} else {
3798
3799
			// Support array or space separated string of keys
3800
			if ( jQuery.isArray( key ) ) {
3801
3802
				// If "name" is an array of keys...
3803
				// When data is initially created, via ("key", "val") signature,
3804
				// keys will be converted to camelCase.
3805
				// Since there is no way to tell _how_ a key was added, remove
3806
				// both plain key and camelCase key. #12786
3807
				// This will only penalize the array argument path.
3808
				name = key.concat( key.map( jQuery.camelCase ) );
3809
			} else {
3810
				camel = jQuery.camelCase( key );
3811
3812
				// Try the string as a key before any manipulation
3813
				if ( key in cache ) {
3814
					name = [ key, camel ];
3815
				} else {
3816
3817
					// If a key with the spaces exists, use it.
3818
					// Otherwise, create an array by matching non-whitespace
3819
					name = camel;
3820
					name = name in cache ?
3821
						[ name ] : ( name.match( rnotwhite ) || [] );
3822
				}
3823
			}
3824
3825
			i = name.length;
3826
3827
			while ( i-- ) {
3828
				delete cache[ name[ i ] ];
3829
			}
3830
		}
3831
3832
		// Remove the expando if there's no more data
3833
		if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
3834
3835
			// Support: Chrome <= 35-45+
3836
			// Webkit & Blink performance suffers when deleting properties
3837
			// from DOM nodes, so set to undefined instead
3838
			// https://code.google.com/p/chromium/issues/detail?id=378607
3839
			if ( owner.nodeType ) {
3840
				owner[ this.expando ] = undefined;
3841
			} else {
3842
				delete owner[ this.expando ];
3843
			}
3844
		}
3845
	},
3846
	hasData: function( owner ) {
3847
		var cache = owner[ this.expando ];
3848
		return cache !== undefined && !jQuery.isEmptyObject( cache );
3849
	}
3850
};
3851
var dataPriv = new Data();
3852
3853
var dataUser = new Data();
3854
3855
3856
3857
//	Implementation Summary
3858
//
3859
//	1. Enforce API surface and semantic compatibility with 1.9.x branch
3860
//	2. Improve the module's maintainability by reducing the storage
3861
//		paths to a single mechanism.
3862
//	3. Use the same single mechanism to support "private" and "user" data.
3863
//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
3864
//	5. Avoid exposing implementation details on user objects (eg. expando properties)
3865
//	6. Provide a clear path for implementation upgrade to WeakMap in 2014
3866
3867
var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
3868
	rmultiDash = /[A-Z]/g;
3869
3870
function dataAttr( elem, key, data ) {
3871
	var name;
3872
3873
	// If nothing was found internally, try to fetch any
3874
	// data from the HTML5 data-* attribute
3875
	if ( data === undefined && elem.nodeType === 1 ) {
3876
		name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
3877
		data = elem.getAttribute( name );
3878
3879
		if ( typeof data === "string" ) {
3880
			try {
3881
				data = data === "true" ? true :
3882
					data === "false" ? false :
3883
					data === "null" ? null :
3884
3885
					// Only convert to a number if it doesn't change the string
3886
					+data + "" === data ? +data :
3887
					rbrace.test( data ) ? jQuery.parseJSON( data ) :
3888
					data;
3889
			} catch ( e ) {}
3890
3891
			// Make sure we set the data so it isn't changed later
3892
			dataUser.set( elem, key, data );
3893
		} else {
3894
			data = undefined;
3895
		}
3896
	}
3897
	return data;
3898
}
3899
3900
jQuery.extend( {
3901
	hasData: function( elem ) {
3902
		return dataUser.hasData( elem ) || dataPriv.hasData( elem );
3903
	},
3904
3905
	data: function( elem, name, data ) {
3906
		return dataUser.access( elem, name, data );
3907
	},
3908
3909
	removeData: function( elem, name ) {
3910
		dataUser.remove( elem, name );
3911
	},
3912
3913
	// TODO: Now that all calls to _data and _removeData have been replaced
3914
	// with direct calls to dataPriv methods, these can be deprecated.
3915
	_data: function( elem, name, data ) {
3916
		return dataPriv.access( elem, name, data );
3917
	},
3918
3919
	_removeData: function( elem, name ) {
3920
		dataPriv.remove( elem, name );
3921
	}
3922
} );
3923
3924
jQuery.fn.extend( {
3925
	data: function( key, value ) {
3926
		var i, name, data,
3927
			elem = this[ 0 ],
3928
			attrs = elem && elem.attributes;
3929
3930
		// Gets all values
3931
		if ( key === undefined ) {
3932
			if ( this.length ) {
3933
				data = dataUser.get( elem );
3934
3935
				if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
3936
					i = attrs.length;
3937
					while ( i-- ) {
3938
3939
						// Support: IE11+
3940
						// The attrs elements can be null (#14894)
3941
						if ( attrs[ i ] ) {
3942
							name = attrs[ i ].name;
3943
							if ( name.indexOf( "data-" ) === 0 ) {
3944
								name = jQuery.camelCase( name.slice( 5 ) );
3945
								dataAttr( elem, name, data[ name ] );
3946
							}
3947
						}
3948
					}
3949
					dataPriv.set( elem, "hasDataAttrs", true );
3950
				}
3951
			}
3952
3953
			return data;
3954
		}
3955
3956
		// Sets multiple values
3957
		if ( typeof key === "object" ) {
3958
			return this.each( function() {
3959
				dataUser.set( this, key );
3960
			} );
3961
		}
3962
3963
		return access( this, function( value ) {
3964
			var data, camelKey;
3965
3966
			// The calling jQuery object (element matches) is not empty
3967
			// (and therefore has an element appears at this[ 0 ]) and the
3968
			// `value` parameter was not undefined. An empty jQuery object
3969
			// will result in `undefined` for elem = this[ 0 ] which will
3970
			// throw an exception if an attempt to read a data cache is made.
3971
			if ( elem && value === undefined ) {
3972
3973
				// Attempt to get data from the cache
3974
				// with the key as-is
3975
				data = dataUser.get( elem, key ) ||
3976
3977
					// Try to find dashed key if it exists (gh-2779)
3978
					// This is for 2.2.x only
3979
					dataUser.get( elem, key.replace( rmultiDash, "-$&" ).toLowerCase() );
3980
3981
				if ( data !== undefined ) {
3982
					return data;
3983
				}
3984
3985
				camelKey = jQuery.camelCase( key );
3986
3987
				// Attempt to get data from the cache
3988
				// with the key camelized
3989
				data = dataUser.get( elem, camelKey );
3990
				if ( data !== undefined ) {
3991
					return data;
3992
				}
3993
3994
				// Attempt to "discover" the data in
3995
				// HTML5 custom data-* attrs
3996
				data = dataAttr( elem, camelKey, undefined );
3997
				if ( data !== undefined ) {
3998
					return data;
3999
				}
4000
4001
				// We tried really hard, but the data doesn't exist.
4002
				return;
4003
			}
4004
4005
			// Set the data...
4006
			camelKey = jQuery.camelCase( key );
4007
			this.each( function() {
4008
4009
				// First, attempt to store a copy or reference of any
4010
				// data that might've been store with a camelCased key.
4011
				var data = dataUser.get( this, camelKey );
4012
4013
				// For HTML5 data-* attribute interop, we have to
4014
				// store property names with dashes in a camelCase form.
4015
				// This might not apply to all properties...*
4016
				dataUser.set( this, camelKey, value );
4017
4018
				// *... In the case of properties that might _actually_
4019
				// have dashes, we need to also store a copy of that
4020
				// unchanged property.
4021
				if ( key.indexOf( "-" ) > -1 && data !== undefined ) {
4022
					dataUser.set( this, key, value );
4023
				}
4024
			} );
4025
		}, null, value, arguments.length > 1, null, true );
4026
	},
4027
4028
	removeData: function( key ) {
4029
		return this.each( function() {
4030
			dataUser.remove( this, key );
4031
		} );
4032
	}
4033
} );
4034
4035
4036
jQuery.extend( {
4037
	queue: function( elem, type, data ) {
4038
		var queue;
4039
4040
		if ( elem ) {
4041
			type = ( type || "fx" ) + "queue";
4042
			queue = dataPriv.get( elem, type );
4043
4044
			// Speed up dequeue by getting out quickly if this is just a lookup
4045
			if ( data ) {
4046
				if ( !queue || jQuery.isArray( data ) ) {
4047
					queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
4048
				} else {
4049
					queue.push( data );
4050
				}
4051
			}
4052
			return queue || [];
4053
		}
4054
	},
4055
4056
	dequeue: function( elem, type ) {
4057
		type = type || "fx";
4058
4059
		var queue = jQuery.queue( elem, type ),
4060
			startLength = queue.length,
4061
			fn = queue.shift(),
4062
			hooks = jQuery._queueHooks( elem, type ),
4063
			next = function() {
4064
				jQuery.dequeue( elem, type );
4065
			};
4066
4067
		// If the fx queue is dequeued, always remove the progress sentinel
4068
		if ( fn === "inprogress" ) {
4069
			fn = queue.shift();
4070
			startLength--;
4071
		}
4072
4073
		if ( fn ) {
4074
4075
			// Add a progress sentinel to prevent the fx queue from being
4076
			// automatically dequeued
4077
			if ( type === "fx" ) {
4078
				queue.unshift( "inprogress" );
4079
			}
4080
4081
			// Clear up the last queue stop function
4082
			delete hooks.stop;
4083
			fn.call( elem, next, hooks );
4084
		}
4085
4086
		if ( !startLength && hooks ) {
4087
			hooks.empty.fire();
4088
		}
4089
	},
4090
4091
	// Not public - generate a queueHooks object, or return the current one
4092
	_queueHooks: function( elem, type ) {
4093
		var key = type + "queueHooks";
4094
		return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
4095
			empty: jQuery.Callbacks( "once memory" ).add( function() {
4096
				dataPriv.remove( elem, [ type + "queue", key ] );
4097
			} )
4098
		} );
4099
	}
4100
} );
4101
4102
jQuery.fn.extend( {
4103
	queue: function( type, data ) {
4104
		var setter = 2;
4105
4106
		if ( typeof type !== "string" ) {
4107
			data = type;
4108
			type = "fx";
4109
			setter--;
4110
		}
4111
4112
		if ( arguments.length < setter ) {
4113
			return jQuery.queue( this[ 0 ], type );
4114
		}
4115
4116
		return data === undefined ?
4117
			this :
4118
			this.each( function() {
4119
				var queue = jQuery.queue( this, type, data );
4120
4121
				// Ensure a hooks for this queue
4122
				jQuery._queueHooks( this, type );
4123
4124
				if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
4125
					jQuery.dequeue( this, type );
4126
				}
4127
			} );
4128
	},
4129
	dequeue: function( type ) {
4130
		return this.each( function() {
4131
			jQuery.dequeue( this, type );
4132
		} );
4133
	},
4134
	clearQueue: function( type ) {
4135
		return this.queue( type || "fx", [] );
4136
	},
4137
4138
	// Get a promise resolved when queues of a certain type
4139
	// are emptied (fx is the type by default)
4140
	promise: function( type, obj ) {
4141
		var tmp,
4142
			count = 1,
4143
			defer = jQuery.Deferred(),
4144
			elements = this,
4145
			i = this.length,
4146
			resolve = function() {
4147
				if ( !( --count ) ) {
4148
					defer.resolveWith( elements, [ elements ] );
4149
				}
4150
			};
4151
4152
		if ( typeof type !== "string" ) {
4153
			obj = type;
4154
			type = undefined;
4155
		}
4156
		type = type || "fx";
4157
4158
		while ( i-- ) {
4159
			tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
4160
			if ( tmp && tmp.empty ) {
4161
				count++;
4162
				tmp.empty.add( resolve );
4163
			}
4164
		}
4165
		resolve();
4166
		return defer.promise( obj );
4167
	}
4168
} );
4169
var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
4170
4171
var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
4172
4173
4174
var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
4175
4176
var isHidden = function( elem, el ) {
4177
4178
		// isHidden might be called from jQuery#filter function;
4179
		// in that case, element will be second argument
4180
		elem = el || elem;
4181
		return jQuery.css( elem, "display" ) === "none" ||
4182
			!jQuery.contains( elem.ownerDocument, elem );
4183
	};
4184
4185
4186
4187
function adjustCSS( elem, prop, valueParts, tween ) {
4188
	var adjusted,
4189
		scale = 1,
4190
		maxIterations = 20,
4191
		currentValue = tween ?
4192
			function() { return tween.cur(); } :
4193
			function() { return jQuery.css( elem, prop, "" ); },
4194
		initial = currentValue(),
4195
		unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
4196
4197
		// Starting value computation is required for potential unit mismatches
4198
		initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
4199
			rcssNum.exec( jQuery.css( elem, prop ) );
4200
4201
	if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
4202
4203
		// Trust units reported by jQuery.css
4204
		unit = unit || initialInUnit[ 3 ];
4205
4206
		// Make sure we update the tween properties later on
4207
		valueParts = valueParts || [];
4208
4209
		// Iteratively approximate from a nonzero starting point
4210
		initialInUnit = +initial || 1;
4211
4212
		do {
4213
4214
			// If previous iteration zeroed out, double until we get *something*.
4215
			// Use string for doubling so we don't accidentally see scale as unchanged below
4216
			scale = scale || ".5";
4217
4218
			// Adjust and apply
4219
			initialInUnit = initialInUnit / scale;
4220
			jQuery.style( elem, prop, initialInUnit + unit );
4221
4222
		// Update scale, tolerating zero or NaN from tween.cur()
4223
		// Break the loop if scale is unchanged or perfect, or if we've just had enough.
4224
		} while (
4225
			scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations
4226
		);
4227
	}
4228
4229
	if ( valueParts ) {
4230
		initialInUnit = +initialInUnit || +initial || 0;
4231
4232
		// Apply relative offset (+=/-=) if specified
4233
		adjusted = valueParts[ 1 ] ?
4234
			initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
4235
			+valueParts[ 2 ];
4236
		if ( tween ) {
4237
			tween.unit = unit;
4238
			tween.start = initialInUnit;
4239
			tween.end = adjusted;
4240
		}
4241
	}
4242
	return adjusted;
4243
}
4244
var rcheckableType = ( /^(?:checkbox|radio)$/i );
4245
4246
var rtagName = ( /<([\w:-]+)/ );
4247
4248
var rscriptType = ( /^$|\/(?:java|ecma)script/i );
4249
4250
4251
4252
// We have to close these tags to support XHTML (#13200)
4253
var wrapMap = {
4254
4255
	// Support: IE9
4256
	option: [ 1, "<select multiple='multiple'>", "</select>" ],
4257
4258
	// XHTML parsers do not magically insert elements in the
4259
	// same way that tag soup parsers do. So we cannot shorten
4260
	// this by omitting <tbody> or other required elements.
4261
	thead: [ 1, "<table>", "</table>" ],
4262
	col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
4263
	tr: [ 2, "<table><tbody>", "</tbody></table>" ],
4264
	td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
4265
4266
	_default: [ 0, "", "" ]
4267
};
4268
4269
// Support: IE9
4270
wrapMap.optgroup = wrapMap.option;
4271
4272
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
4273
wrapMap.th = wrapMap.td;
4274
4275
4276
function getAll( context, tag ) {
4277
4278
	// Support: IE9-11+
4279
	// Use typeof to avoid zero-argument method invocation on host objects (#15151)
4280
	var ret = typeof context.getElementsByTagName !== "undefined" ?
4281
			context.getElementsByTagName( tag || "*" ) :
4282
			typeof context.querySelectorAll !== "undefined" ?
4283
				context.querySelectorAll( tag || "*" ) :
4284
			[];
4285
4286
	return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
4287
		jQuery.merge( [ context ], ret ) :
4288
		ret;
4289
}
4290
4291
4292
// Mark scripts as having already been evaluated
4293
function setGlobalEval( elems, refElements ) {
4294
	var i = 0,
4295
		l = elems.length;
4296
4297
	for ( ; i < l; i++ ) {
4298
		dataPriv.set(
4299
			elems[ i ],
4300
			"globalEval",
4301
			!refElements || dataPriv.get( refElements[ i ], "globalEval" )
4302
		);
4303
	}
4304
}
4305
4306
4307
var rhtml = /<|&#?\w+;/;
4308
4309
function buildFragment( elems, context, scripts, selection, ignored ) {
4310
	var elem, tmp, tag, wrap, contains, j,
4311
		fragment = context.createDocumentFragment(),
4312
		nodes = [],
4313
		i = 0,
4314
		l = elems.length;
4315
4316
	for ( ; i < l; i++ ) {
4317
		elem = elems[ i ];
4318
4319
		if ( elem || elem === 0 ) {
4320
4321
			// Add nodes directly
4322
			if ( jQuery.type( elem ) === "object" ) {
4323
4324
				// Support: Android<4.1, PhantomJS<2
4325
				// push.apply(_, arraylike) throws on ancient WebKit
4326
				jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
4327
4328
			// Convert non-html into a text node
4329
			} else if ( !rhtml.test( elem ) ) {
4330
				nodes.push( context.createTextNode( elem ) );
4331
4332
			// Convert html into DOM nodes
4333
			} else {
4334
				tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
4335
4336
				// Deserialize a standard representation
4337
				tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
4338
				wrap = wrapMap[ tag ] || wrapMap._default;
4339
				tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
4340
4341
				// Descend through wrappers to the right content
4342
				j = wrap[ 0 ];
4343
				while ( j-- ) {
4344
					tmp = tmp.lastChild;
4345
				}
4346
4347
				// Support: Android<4.1, PhantomJS<2
4348
				// push.apply(_, arraylike) throws on ancient WebKit
4349
				jQuery.merge( nodes, tmp.childNodes );
4350
4351
				// Remember the top-level container
4352
				tmp = fragment.firstChild;
4353
4354
				// Ensure the created nodes are orphaned (#12392)
4355
				tmp.textContent = "";
4356
			}
4357
		}
4358
	}
4359
4360
	// Remove wrapper from fragment
4361
	fragment.textContent = "";
4362
4363
	i = 0;
4364
	while ( ( elem = nodes[ i++ ] ) ) {
4365
4366
		// Skip elements already in the context collection (trac-4087)
4367
		if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
4368
			if ( ignored ) {
4369
				ignored.push( elem );
4370
			}
4371
			continue;
4372
		}
4373
4374
		contains = jQuery.contains( elem.ownerDocument, elem );
4375
4376
		// Append to fragment
4377
		tmp = getAll( fragment.appendChild( elem ), "script" );
4378
4379
		// Preserve script evaluation history
4380
		if ( contains ) {
4381
			setGlobalEval( tmp );
4382
		}
4383
4384
		// Capture executables
4385
		if ( scripts ) {
4386
			j = 0;
4387
			while ( ( elem = tmp[ j++ ] ) ) {
4388
				if ( rscriptType.test( elem.type || "" ) ) {
4389
					scripts.push( elem );
4390
				}
4391
			}
4392
		}
4393
	}
4394
4395
	return fragment;
4396
}
4397
4398
4399
( function() {
4400
	var fragment = document.createDocumentFragment(),
4401
		div = fragment.appendChild( document.createElement( "div" ) ),
4402
		input = document.createElement( "input" );
4403
4404
	// Support: Android 4.0-4.3, Safari<=5.1
4405
	// Check state lost if the name is set (#11217)
4406
	// Support: Windows Web Apps (WWA)
4407
	// `name` and `type` must use .setAttribute for WWA (#14901)
4408
	input.setAttribute( "type", "radio" );
4409
	input.setAttribute( "checked", "checked" );
4410
	input.setAttribute( "name", "t" );
4411
4412
	div.appendChild( input );
4413
4414
	// Support: Safari<=5.1, Android<4.2
4415
	// Older WebKit doesn't clone checked state correctly in fragments
4416
	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
4417
4418
	// Support: IE<=11+
4419
	// Make sure textarea (and checkbox) defaultValue is properly cloned
4420
	div.innerHTML = "<textarea>x</textarea>";
4421
	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
4422
} )();
4423
4424
4425
var
4426
	rkeyEvent = /^key/,
4427
	rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
4428
	rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
4429
4430
function returnTrue() {
4431
	return true;
4432
}
4433
4434
function returnFalse() {
4435
	return false;
4436
}
4437
4438
// Support: IE9
4439
// See #13393 for more info
4440
function safeActiveElement() {
4441
	try {
4442
		return document.activeElement;
4443
	} catch ( err ) { }
4444
}
4445
4446
function on( elem, types, selector, data, fn, one ) {
4447
	var origFn, type;
4448
4449
	// Types can be a map of types/handlers
4450
	if ( typeof types === "object" ) {
4451
4452
		// ( types-Object, selector, data )
4453
		if ( typeof selector !== "string" ) {
4454
4455
			// ( types-Object, data )
4456
			data = data || selector;
4457
			selector = undefined;
4458
		}
4459
		for ( type in types ) {
4460
			on( elem, type, selector, data, types[ type ], one );
4461
		}
4462
		return elem;
4463
	}
4464
4465
	if ( data == null && fn == null ) {
4466
4467
		// ( types, fn )
4468
		fn = selector;
4469
		data = selector = undefined;
4470
	} else if ( fn == null ) {
4471
		if ( typeof selector === "string" ) {
4472
4473
			// ( types, selector, fn )
4474
			fn = data;
4475
			data = undefined;
4476
		} else {
4477
4478
			// ( types, data, fn )
4479
			fn = data;
4480
			data = selector;
4481
			selector = undefined;
4482
		}
4483
	}
4484
	if ( fn === false ) {
4485
		fn = returnFalse;
4486
	} else if ( !fn ) {
4487
		return elem;
4488
	}
4489
4490
	if ( one === 1 ) {
4491
		origFn = fn;
4492
		fn = function( event ) {
4493
4494
			// Can use an empty set, since event contains the info
4495
			jQuery().off( event );
4496
			return origFn.apply( this, arguments );
4497
		};
4498
4499
		// Use same guid so caller can remove using origFn
4500
		fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
4501
	}
4502
	return elem.each( function() {
4503
		jQuery.event.add( this, types, fn, data, selector );
4504
	} );
4505
}
4506
4507
/*
4508
 * Helper functions for managing events -- not part of the public interface.
4509
 * Props to Dean Edwards' addEvent library for many of the ideas.
4510
 */
4511
jQuery.event = {
4512
4513
	global: {},
4514
4515
	add: function( elem, types, handler, data, selector ) {
4516
4517
		var handleObjIn, eventHandle, tmp,
4518
			events, t, handleObj,
4519
			special, handlers, type, namespaces, origType,
4520
			elemData = dataPriv.get( elem );
4521
4522
		// Don't attach events to noData or text/comment nodes (but allow plain objects)
4523
		if ( !elemData ) {
4524
			return;
4525
		}
4526
4527
		// Caller can pass in an object of custom data in lieu of the handler
4528
		if ( handler.handler ) {
4529
			handleObjIn = handler;
4530
			handler = handleObjIn.handler;
4531
			selector = handleObjIn.selector;
4532
		}
4533
4534
		// Make sure that the handler has a unique ID, used to find/remove it later
4535
		if ( !handler.guid ) {
4536
			handler.guid = jQuery.guid++;
4537
		}
4538
4539
		// Init the element's event structure and main handler, if this is the first
4540
		if ( !( events = elemData.events ) ) {
4541
			events = elemData.events = {};
4542
		}
4543
		if ( !( eventHandle = elemData.handle ) ) {
4544
			eventHandle = elemData.handle = function( e ) {
4545
4546
				// Discard the second event of a jQuery.event.trigger() and
4547
				// when an event is called after a page has unloaded
4548
				return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
4549
					jQuery.event.dispatch.apply( elem, arguments ) : undefined;
4550
			};
4551
		}
4552
4553
		// Handle multiple events separated by a space
4554
		types = ( types || "" ).match( rnotwhite ) || [ "" ];
4555
		t = types.length;
4556
		while ( t-- ) {
4557
			tmp = rtypenamespace.exec( types[ t ] ) || [];
4558
			type = origType = tmp[ 1 ];
4559
			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
4560
4561
			// There *must* be a type, no attaching namespace-only handlers
4562
			if ( !type ) {
4563
				continue;
4564
			}
4565
4566
			// If event changes its type, use the special event handlers for the changed type
4567
			special = jQuery.event.special[ type ] || {};
4568
4569
			// If selector defined, determine special event api type, otherwise given type
4570
			type = ( selector ? special.delegateType : special.bindType ) || type;
4571
4572
			// Update special based on newly reset type
4573
			special = jQuery.event.special[ type ] || {};
4574
4575
			// handleObj is passed to all event handlers
4576
			handleObj = jQuery.extend( {
4577
				type: type,
4578
				origType: origType,
4579
				data: data,
4580
				handler: handler,
4581
				guid: handler.guid,
4582
				selector: selector,
4583
				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
4584
				namespace: namespaces.join( "." )
4585
			}, handleObjIn );
4586
4587
			// Init the event handler queue if we're the first
4588
			if ( !( handlers = events[ type ] ) ) {
4589
				handlers = events[ type ] = [];
4590
				handlers.delegateCount = 0;
4591
4592
				// Only use addEventListener if the special events handler returns false
4593
				if ( !special.setup ||
4594
					special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
4595
4596
					if ( elem.addEventListener ) {
4597
						elem.addEventListener( type, eventHandle );
4598
					}
4599
				}
4600
			}
4601
4602
			if ( special.add ) {
4603
				special.add.call( elem, handleObj );
4604
4605
				if ( !handleObj.handler.guid ) {
4606
					handleObj.handler.guid = handler.guid;
4607
				}
4608
			}
4609
4610
			// Add to the element's handler list, delegates in front
4611
			if ( selector ) {
4612
				handlers.splice( handlers.delegateCount++, 0, handleObj );
4613
			} else {
4614
				handlers.push( handleObj );
4615
			}
4616
4617
			// Keep track of which events have ever been used, for event optimization
4618
			jQuery.event.global[ type ] = true;
4619
		}
4620
4621
	},
4622
4623
	// Detach an event or set of events from an element
4624
	remove: function( elem, types, handler, selector, mappedTypes ) {
4625
4626
		var j, origCount, tmp,
4627
			events, t, handleObj,
4628
			special, handlers, type, namespaces, origType,
4629
			elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
4630
4631
		if ( !elemData || !( events = elemData.events ) ) {
4632
			return;
4633
		}
4634
4635
		// Once for each type.namespace in types; type may be omitted
4636
		types = ( types || "" ).match( rnotwhite ) || [ "" ];
4637
		t = types.length;
4638
		while ( t-- ) {
4639
			tmp = rtypenamespace.exec( types[ t ] ) || [];
4640
			type = origType = tmp[ 1 ];
4641
			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
4642
4643
			// Unbind all events (on this namespace, if provided) for the element
4644
			if ( !type ) {
4645
				for ( type in events ) {
4646
					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
4647
				}
4648
				continue;
4649
			}
4650
4651
			special = jQuery.event.special[ type ] || {};
4652
			type = ( selector ? special.delegateType : special.bindType ) || type;
4653
			handlers = events[ type ] || [];
4654
			tmp = tmp[ 2 ] &&
4655
				new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
4656
4657
			// Remove matching events
4658
			origCount = j = handlers.length;
4659
			while ( j-- ) {
4660
				handleObj = handlers[ j ];
4661
4662
				if ( ( mappedTypes || origType === handleObj.origType ) &&
4663
					( !handler || handler.guid === handleObj.guid ) &&
4664
					( !tmp || tmp.test( handleObj.namespace ) ) &&
4665
					( !selector || selector === handleObj.selector ||
4666
						selector === "**" && handleObj.selector ) ) {
4667
					handlers.splice( j, 1 );
4668
4669
					if ( handleObj.selector ) {
4670
						handlers.delegateCount--;
4671
					}
4672
					if ( special.remove ) {
4673
						special.remove.call( elem, handleObj );
4674
					}
4675
				}
4676
			}
4677
4678
			// Remove generic event handler if we removed something and no more handlers exist
4679
			// (avoids potential for endless recursion during removal of special event handlers)
4680
			if ( origCount && !handlers.length ) {
4681
				if ( !special.teardown ||
4682
					special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
4683
4684
					jQuery.removeEvent( elem, type, elemData.handle );
4685
				}
4686
4687
				delete events[ type ];
4688
			}
4689
		}
4690
4691
		// Remove data and the expando if it's no longer used
4692
		if ( jQuery.isEmptyObject( events ) ) {
4693
			dataPriv.remove( elem, "handle events" );
4694
		}
4695
	},
4696
4697
	dispatch: function( event ) {
4698
4699
		// Make a writable jQuery.Event from the native event object
4700
		event = jQuery.event.fix( event );
4701
4702
		var i, j, ret, matched, handleObj,
4703
			handlerQueue = [],
4704
			args = slice.call( arguments ),
4705
			handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
4706
			special = jQuery.event.special[ event.type ] || {};
4707
4708
		// Use the fix-ed jQuery.Event rather than the (read-only) native event
4709
		args[ 0 ] = event;
4710
		event.delegateTarget = this;
4711
4712
		// Call the preDispatch hook for the mapped type, and let it bail if desired
4713
		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
4714
			return;
4715
		}
4716
4717
		// Determine handlers
4718
		handlerQueue = jQuery.event.handlers.call( this, event, handlers );
4719
4720
		// Run delegates first; they may want to stop propagation beneath us
4721
		i = 0;
4722
		while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
4723
			event.currentTarget = matched.elem;
4724
4725
			j = 0;
4726
			while ( ( handleObj = matched.handlers[ j++ ] ) &&
4727
				!event.isImmediatePropagationStopped() ) {
4728
4729
				// Triggered event must either 1) have no namespace, or 2) have namespace(s)
4730
				// a subset or equal to those in the bound event (both can have no namespace).
4731
				if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {
4732
4733
					event.handleObj = handleObj;
4734
					event.data = handleObj.data;
4735
4736
					ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
4737
						handleObj.handler ).apply( matched.elem, args );
4738
4739
					if ( ret !== undefined ) {
4740
						if ( ( event.result = ret ) === false ) {
4741
							event.preventDefault();
4742
							event.stopPropagation();
4743
						}
4744
					}
4745
				}
4746
			}
4747
		}
4748
4749
		// Call the postDispatch hook for the mapped type
4750
		if ( special.postDispatch ) {
4751
			special.postDispatch.call( this, event );
4752
		}
4753
4754
		return event.result;
4755
	},
4756
4757
	handlers: function( event, handlers ) {
4758
		var i, matches, sel, handleObj,
4759
			handlerQueue = [],
4760
			delegateCount = handlers.delegateCount,
4761
			cur = event.target;
4762
4763
		// Support (at least): Chrome, IE9
4764
		// Find delegate handlers
4765
		// Black-hole SVG <use> instance trees (#13180)
4766
		//
4767
		// Support: Firefox<=42+
4768
		// Avoid non-left-click in FF but don't block IE radio events (#3861, gh-2343)
4769
		if ( delegateCount && cur.nodeType &&
4770
			( event.type !== "click" || isNaN( event.button ) || event.button < 1 ) ) {
4771
4772
			for ( ; cur !== this; cur = cur.parentNode || this ) {
4773
4774
				// Don't check non-elements (#13208)
4775
				// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
4776
				if ( cur.nodeType === 1 && ( cur.disabled !== true || event.type !== "click" ) ) {
4777
					matches = [];
4778
					for ( i = 0; i < delegateCount; i++ ) {
4779
						handleObj = handlers[ i ];
4780
4781
						// Don't conflict with Object.prototype properties (#13203)
4782
						sel = handleObj.selector + " ";
4783
4784
						if ( matches[ sel ] === undefined ) {
4785
							matches[ sel ] = handleObj.needsContext ?
4786
								jQuery( sel, this ).index( cur ) > -1 :
4787
								jQuery.find( sel, this, null, [ cur ] ).length;
4788
						}
4789
						if ( matches[ sel ] ) {
4790
							matches.push( handleObj );
4791
						}
4792
					}
4793
					if ( matches.length ) {
4794
						handlerQueue.push( { elem: cur, handlers: matches } );
4795
					}
4796
				}
4797
			}
4798
		}
4799
4800
		// Add the remaining (directly-bound) handlers
4801
		if ( delegateCount < handlers.length ) {
4802
			handlerQueue.push( { elem: this, handlers: handlers.slice( delegateCount ) } );
4803
		}
4804
4805
		return handlerQueue;
4806
	},
4807
4808
	// Includes some event props shared by KeyEvent and MouseEvent
4809
	props: ( "altKey bubbles cancelable ctrlKey currentTarget detail eventPhase " +
4810
		"metaKey relatedTarget shiftKey target timeStamp view which" ).split( " " ),
4811
4812
	fixHooks: {},
4813
4814
	keyHooks: {
4815
		props: "char charCode key keyCode".split( " " ),
4816
		filter: function( event, original ) {
4817
4818
			// Add which for key events
4819
			if ( event.which == null ) {
4820
				event.which = original.charCode != null ? original.charCode : original.keyCode;
4821
			}
4822
4823
			return event;
4824
		}
4825
	},
4826
4827
	mouseHooks: {
4828
		props: ( "button buttons clientX clientY offsetX offsetY pageX pageY " +
4829
			"screenX screenY toElement" ).split( " " ),
4830
		filter: function( event, original ) {
4831
			var eventDoc, doc, body,
4832
				button = original.button;
4833
4834
			// Calculate pageX/Y if missing and clientX/Y available
4835
			if ( event.pageX == null && original.clientX != null ) {
4836
				eventDoc = event.target.ownerDocument || document;
4837
				doc = eventDoc.documentElement;
4838
				body = eventDoc.body;
4839
4840
				event.pageX = original.clientX +
4841
					( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) -
4842
					( doc && doc.clientLeft || body && body.clientLeft || 0 );
4843
				event.pageY = original.clientY +
4844
					( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) -
4845
					( doc && doc.clientTop  || body && body.clientTop  || 0 );
4846
			}
4847
4848
			// Add which for click: 1 === left; 2 === middle; 3 === right
4849
			// Note: button is not normalized, so don't use it
4850
			if ( !event.which && button !== undefined ) {
4851
				event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
4852
			}
4853
4854
			return event;
4855
		}
4856
	},
4857
4858
	fix: function( event ) {
4859
		if ( event[ jQuery.expando ] ) {
4860
			return event;
4861
		}
4862
4863
		// Create a writable copy of the event object and normalize some properties
4864
		var i, prop, copy,
4865
			type = event.type,
4866
			originalEvent = event,
4867
			fixHook = this.fixHooks[ type ];
4868
4869
		if ( !fixHook ) {
4870
			this.fixHooks[ type ] = fixHook =
4871
				rmouseEvent.test( type ) ? this.mouseHooks :
4872
				rkeyEvent.test( type ) ? this.keyHooks :
4873
				{};
4874
		}
4875
		copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
4876
4877
		event = new jQuery.Event( originalEvent );
4878
4879
		i = copy.length;
4880
		while ( i-- ) {
4881
			prop = copy[ i ];
4882
			event[ prop ] = originalEvent[ prop ];
4883
		}
4884
4885
		// Support: Cordova 2.5 (WebKit) (#13255)
4886
		// All events should have a target; Cordova deviceready doesn't
4887
		if ( !event.target ) {
4888
			event.target = document;
4889
		}
4890
4891
		// Support: Safari 6.0+, Chrome<28
4892
		// Target should not be a text node (#504, #13143)
4893
		if ( event.target.nodeType === 3 ) {
4894
			event.target = event.target.parentNode;
4895
		}
4896
4897
		return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
4898
	},
4899
4900
	special: {
4901
		load: {
4902
4903
			// Prevent triggered image.load events from bubbling to window.load
4904
			noBubble: true
4905
		},
4906
		focus: {
4907
4908
			// Fire native event if possible so blur/focus sequence is correct
4909
			trigger: function() {
4910
				if ( this !== safeActiveElement() && this.focus ) {
4911
					this.focus();
4912
					return false;
4913
				}
4914
			},
4915
			delegateType: "focusin"
4916
		},
4917
		blur: {
4918
			trigger: function() {
4919
				if ( this === safeActiveElement() && this.blur ) {
4920
					this.blur();
4921
					return false;
4922
				}
4923
			},
4924
			delegateType: "focusout"
4925
		},
4926
		click: {
4927
4928
			// For checkbox, fire native event so checked state will be right
4929
			trigger: function() {
4930
				if ( this.type === "checkbox" && this.click && jQuery.nodeName( this, "input" ) ) {
4931
					this.click();
4932
					return false;
4933
				}
4934
			},
4935
4936
			// For cross-browser consistency, don't fire native .click() on links
4937
			_default: function( event ) {
4938
				return jQuery.nodeName( event.target, "a" );
4939
			}
4940
		},
4941
4942
		beforeunload: {
4943
			postDispatch: function( event ) {
4944
4945
				// Support: Firefox 20+
4946
				// Firefox doesn't alert if the returnValue field is not set.
4947
				if ( event.result !== undefined && event.originalEvent ) {
4948
					event.originalEvent.returnValue = event.result;
4949
				}
4950
			}
4951
		}
4952
	}
4953
};
4954
4955
jQuery.removeEvent = function( elem, type, handle ) {
4956
4957
	// This "if" is needed for plain objects
4958
	if ( elem.removeEventListener ) {
4959
		elem.removeEventListener( type, handle );
4960
	}
4961
};
4962
4963
jQuery.Event = function( src, props ) {
4964
4965
	// Allow instantiation without the 'new' keyword
4966
	if ( !( this instanceof jQuery.Event ) ) {
4967
		return new jQuery.Event( src, props );
4968
	}
4969
4970
	// Event object
4971
	if ( src && src.type ) {
4972
		this.originalEvent = src;
4973
		this.type = src.type;
4974
4975
		// Events bubbling up the document may have been marked as prevented
4976
		// by a handler lower down the tree; reflect the correct value.
4977
		this.isDefaultPrevented = src.defaultPrevented ||
4978
				src.defaultPrevented === undefined &&
4979
4980
				// Support: Android<4.0
4981
				src.returnValue === false ?
4982
			returnTrue :
4983
			returnFalse;
4984
4985
	// Event type
4986
	} else {
4987
		this.type = src;
4988
	}
4989
4990
	// Put explicitly provided properties onto the event object
4991
	if ( props ) {
4992
		jQuery.extend( this, props );
4993
	}
4994
4995
	// Create a timestamp if incoming event doesn't have one
4996
	this.timeStamp = src && src.timeStamp || jQuery.now();
4997
4998
	// Mark it as fixed
4999
	this[ jQuery.expando ] = true;
5000
};
5001
5002
// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
5003
// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
5004
jQuery.Event.prototype = {
5005
	constructor: jQuery.Event,
5006
	isDefaultPrevented: returnFalse,
5007
	isPropagationStopped: returnFalse,
5008
	isImmediatePropagationStopped: returnFalse,
5009
5010
	preventDefault: function() {
5011
		var e = this.originalEvent;
5012
5013
		this.isDefaultPrevented = returnTrue;
5014
5015
		if ( e ) {
5016
			e.preventDefault();
5017
		}
5018
	},
5019
	stopPropagation: function() {
5020
		var e = this.originalEvent;
5021
5022
		this.isPropagationStopped = returnTrue;
5023
5024
		if ( e ) {
5025
			e.stopPropagation();
5026
		}
5027
	},
5028
	stopImmediatePropagation: function() {
5029
		var e = this.originalEvent;
5030
5031
		this.isImmediatePropagationStopped = returnTrue;
5032
5033
		if ( e ) {
5034
			e.stopImmediatePropagation();
5035
		}
5036
5037
		this.stopPropagation();
5038
	}
5039
};
5040
5041
// Create mouseenter/leave events using mouseover/out and event-time checks
5042
// so that event delegation works in jQuery.
5043
// Do the same for pointerenter/pointerleave and pointerover/pointerout
5044
//
5045
// Support: Safari 7 only
5046
// Safari sends mouseenter too often; see:
5047
// https://code.google.com/p/chromium/issues/detail?id=470258
5048
// for the description of the bug (it existed in older Chrome versions as well).
5049
jQuery.each( {
5050
	mouseenter: "mouseover",
5051
	mouseleave: "mouseout",
5052
	pointerenter: "pointerover",
5053
	pointerleave: "pointerout"
5054
}, function( orig, fix ) {
5055
	jQuery.event.special[ orig ] = {
5056
		delegateType: fix,
5057
		bindType: fix,
5058
5059
		handle: function( event ) {
5060
			var ret,
5061
				target = this,
5062
				related = event.relatedTarget,
5063
				handleObj = event.handleObj;
5064
5065
			// For mouseenter/leave call the handler if related is outside the target.
5066
			// NB: No relatedTarget if the mouse left/entered the browser window
5067
			if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
5068
				event.type = handleObj.origType;
5069
				ret = handleObj.handler.apply( this, arguments );
5070
				event.type = fix;
5071
			}
5072
			return ret;
5073
		}
5074
	};
5075
} );
5076
5077
jQuery.fn.extend( {
5078
	on: function( types, selector, data, fn ) {
5079
		return on( this, types, selector, data, fn );
5080
	},
5081
	one: function( types, selector, data, fn ) {
5082
		return on( this, types, selector, data, fn, 1 );
5083
	},
5084
	off: function( types, selector, fn ) {
5085
		var handleObj, type;
5086
		if ( types && types.preventDefault && types.handleObj ) {
5087
5088
			// ( event )  dispatched jQuery.Event
5089
			handleObj = types.handleObj;
5090
			jQuery( types.delegateTarget ).off(
5091
				handleObj.namespace ?
5092
					handleObj.origType + "." + handleObj.namespace :
5093
					handleObj.origType,
5094
				handleObj.selector,
5095
				handleObj.handler
5096
			);
5097
			return this;
5098
		}
5099
		if ( typeof types === "object" ) {
5100
5101
			// ( types-object [, selector] )
5102
			for ( type in types ) {
5103
				this.off( type, selector, types[ type ] );
5104
			}
5105
			return this;
5106
		}
5107
		if ( selector === false || typeof selector === "function" ) {
5108
5109
			// ( types [, fn] )
5110
			fn = selector;
5111
			selector = undefined;
5112
		}
5113
		if ( fn === false ) {
5114
			fn = returnFalse;
5115
		}
5116
		return this.each( function() {
5117
			jQuery.event.remove( this, types, fn, selector );
5118
		} );
5119
	}
5120
} );
5121
5122
5123
var
5124
	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi,
5125
5126
	// Support: IE 10-11, Edge 10240+
5127
	// In IE/Edge using regex groups here causes severe slowdowns.
5128
	// See https://connect.microsoft.com/IE/feedback/details/1736512/
5129
	rnoInnerhtml = /<script|<style|<link/i,
5130
5131
	// checked="checked" or checked
5132
	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5133
	rscriptTypeMasked = /^true\/(.*)/,
5134
	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
5135
5136
// Manipulating tables requires a tbody
5137
function manipulationTarget( elem, content ) {
5138
	return jQuery.nodeName( elem, "table" ) &&
5139
		jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ?
5140
5141
		elem.getElementsByTagName( "tbody" )[ 0 ] ||
5142
			elem.appendChild( elem.ownerDocument.createElement( "tbody" ) ) :
5143
		elem;
5144
}
5145
5146
// Replace/restore the type attribute of script elements for safe DOM manipulation
5147
function disableScript( elem ) {
5148
	elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
5149
	return elem;
5150
}
5151
function restoreScript( elem ) {
5152
	var match = rscriptTypeMasked.exec( elem.type );
5153
5154
	if ( match ) {
5155
		elem.type = match[ 1 ];
5156
	} else {
5157
		elem.removeAttribute( "type" );
5158
	}
5159
5160
	return elem;
5161
}
5162
5163
function cloneCopyEvent( src, dest ) {
5164
	var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
5165
5166
	if ( dest.nodeType !== 1 ) {
5167
		return;
5168
	}
5169
5170
	// 1. Copy private data: events, handlers, etc.
5171
	if ( dataPriv.hasData( src ) ) {
5172
		pdataOld = dataPriv.access( src );
5173
		pdataCur = dataPriv.set( dest, pdataOld );
5174
		events = pdataOld.events;
5175
5176
		if ( events ) {
5177
			delete pdataCur.handle;
5178
			pdataCur.events = {};
5179
5180
			for ( type in events ) {
5181
				for ( i = 0, l = events[ type ].length; i < l; i++ ) {
5182
					jQuery.event.add( dest, type, events[ type ][ i ] );
5183
				}
5184
			}
5185
		}
5186
	}
5187
5188
	// 2. Copy user data
5189
	if ( dataUser.hasData( src ) ) {
5190
		udataOld = dataUser.access( src );
5191
		udataCur = jQuery.extend( {}, udataOld );
5192
5193
		dataUser.set( dest, udataCur );
5194
	}
5195
}
5196
5197
// Fix IE bugs, see support tests
5198
function fixInput( src, dest ) {
5199
	var nodeName = dest.nodeName.toLowerCase();
5200
5201
	// Fails to persist the checked state of a cloned checkbox or radio button.
5202
	if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
5203
		dest.checked = src.checked;
5204
5205
	// Fails to return the selected option to the default selected state when cloning options
5206
	} else if ( nodeName === "input" || nodeName === "textarea" ) {
5207
		dest.defaultValue = src.defaultValue;
5208
	}
5209
}
5210
5211
function domManip( collection, args, callback, ignored ) {
5212
5213
	// Flatten any nested arrays
5214
	args = concat.apply( [], args );
5215
5216
	var fragment, first, scripts, hasScripts, node, doc,
5217
		i = 0,
5218
		l = collection.length,
5219
		iNoClone = l - 1,
5220
		value = args[ 0 ],
5221
		isFunction = jQuery.isFunction( value );
5222
5223
	// We can't cloneNode fragments that contain checked, in WebKit
5224
	if ( isFunction ||
5225
			( l > 1 && typeof value === "string" &&
5226
				!support.checkClone && rchecked.test( value ) ) ) {
5227
		return collection.each( function( index ) {
5228
			var self = collection.eq( index );
5229
			if ( isFunction ) {
5230
				args[ 0 ] = value.call( this, index, self.html() );
5231
			}
5232
			domManip( self, args, callback, ignored );
5233
		} );
5234
	}
5235
5236
	if ( l ) {
5237
		fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
5238
		first = fragment.firstChild;
5239
5240
		if ( fragment.childNodes.length === 1 ) {
5241
			fragment = first;
5242
		}
5243
5244
		// Require either new content or an interest in ignored elements to invoke the callback
5245
		if ( first || ignored ) {
5246
			scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
5247
			hasScripts = scripts.length;
5248
5249
			// Use the original fragment for the last item
5250
			// instead of the first because it can end up
5251
			// being emptied incorrectly in certain situations (#8070).
5252
			for ( ; i < l; i++ ) {
5253
				node = fragment;
5254
5255
				if ( i !== iNoClone ) {
5256
					node = jQuery.clone( node, true, true );
5257
5258
					// Keep references to cloned scripts for later restoration
5259
					if ( hasScripts ) {
5260
5261
						// Support: Android<4.1, PhantomJS<2
5262
						// push.apply(_, arraylike) throws on ancient WebKit
5263
						jQuery.merge( scripts, getAll( node, "script" ) );
5264
					}
5265
				}
5266
5267
				callback.call( collection[ i ], node, i );
5268
			}
5269
5270
			if ( hasScripts ) {
5271
				doc = scripts[ scripts.length - 1 ].ownerDocument;
5272
5273
				// Reenable scripts
5274
				jQuery.map( scripts, restoreScript );
5275
5276
				// Evaluate executable scripts on first document insertion
5277
				for ( i = 0; i < hasScripts; i++ ) {
5278
					node = scripts[ i ];
5279
					if ( rscriptType.test( node.type || "" ) &&
5280
						!dataPriv.access( node, "globalEval" ) &&
5281
						jQuery.contains( doc, node ) ) {
5282
5283
						if ( node.src ) {
5284
5285
							// Optional AJAX dependency, but won't run scripts if not present
5286
							if ( jQuery._evalUrl ) {
5287
								jQuery._evalUrl( node.src );
5288
							}
5289
						} else {
5290
							jQuery.globalEval( node.textContent.replace( rcleanScript, "" ) );
5291
						}
5292
					}
5293
				}
5294
			}
5295
		}
5296
	}
5297
5298
	return collection;
5299
}
5300
5301
function remove( elem, selector, keepData ) {
5302
	var node,
5303
		nodes = selector ? jQuery.filter( selector, elem ) : elem,
5304
		i = 0;
5305
5306
	for ( ; ( node = nodes[ i ] ) != null; i++ ) {
5307
		if ( !keepData && node.nodeType === 1 ) {
5308
			jQuery.cleanData( getAll( node ) );
5309
		}
5310
5311
		if ( node.parentNode ) {
5312
			if ( keepData && jQuery.contains( node.ownerDocument, node ) ) {
5313
				setGlobalEval( getAll( node, "script" ) );
5314
			}
5315
			node.parentNode.removeChild( node );
5316
		}
5317
	}
5318
5319
	return elem;
5320
}
5321
5322
jQuery.extend( {
5323
	htmlPrefilter: function( html ) {
5324
		return html.replace( rxhtmlTag, "<$1></$2>" );
5325
	},
5326
5327
	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
5328
		var i, l, srcElements, destElements,
5329
			clone = elem.cloneNode( true ),
5330
			inPage = jQuery.contains( elem.ownerDocument, elem );
5331
5332
		// Fix IE cloning issues
5333
		if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
5334
				!jQuery.isXMLDoc( elem ) ) {
5335
5336
			// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
5337
			destElements = getAll( clone );
5338
			srcElements = getAll( elem );
5339
5340
			for ( i = 0, l = srcElements.length; i < l; i++ ) {
5341
				fixInput( srcElements[ i ], destElements[ i ] );
5342
			}
5343
		}
5344
5345
		// Copy the events from the original to the clone
5346
		if ( dataAndEvents ) {
5347
			if ( deepDataAndEvents ) {
5348
				srcElements = srcElements || getAll( elem );
5349
				destElements = destElements || getAll( clone );
5350
5351
				for ( i = 0, l = srcElements.length; i < l; i++ ) {
5352
					cloneCopyEvent( srcElements[ i ], destElements[ i ] );
5353
				}
5354
			} else {
5355
				cloneCopyEvent( elem, clone );
5356
			}
5357
		}
5358
5359
		// Preserve script evaluation history
5360
		destElements = getAll( clone, "script" );
5361
		if ( destElements.length > 0 ) {
5362
			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
5363
		}
5364
5365
		// Return the cloned set
5366
		return clone;
5367
	},
5368
5369
	cleanData: function( elems ) {
5370
		var data, elem, type,
5371
			special = jQuery.event.special,
5372
			i = 0;
5373
5374
		for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
5375
			if ( acceptData( elem ) ) {
5376
				if ( ( data = elem[ dataPriv.expando ] ) ) {
5377
					if ( data.events ) {
5378
						for ( type in data.events ) {
5379
							if ( special[ type ] ) {
5380
								jQuery.event.remove( elem, type );
5381
5382
							// This is a shortcut to avoid jQuery.event.remove's overhead
5383
							} else {
5384
								jQuery.removeEvent( elem, type, data.handle );
5385
							}
5386
						}
5387
					}
5388
5389
					// Support: Chrome <= 35-45+
5390
					// Assign undefined instead of using delete, see Data#remove
5391
					elem[ dataPriv.expando ] = undefined;
5392
				}
5393
				if ( elem[ dataUser.expando ] ) {
5394
5395
					// Support: Chrome <= 35-45+
5396
					// Assign undefined instead of using delete, see Data#remove
5397
					elem[ dataUser.expando ] = undefined;
5398
				}
5399
			}
5400
		}
5401
	}
5402
} );
5403
5404
jQuery.fn.extend( {
5405
5406
	// Keep domManip exposed until 3.0 (gh-2225)
5407
	domManip: domManip,
5408
5409
	detach: function( selector ) {
5410
		return remove( this, selector, true );
5411
	},
5412
5413
	remove: function( selector ) {
5414
		return remove( this, selector );
5415
	},
5416
5417
	text: function( value ) {
5418
		return access( this, function( value ) {
5419
			return value === undefined ?
5420
				jQuery.text( this ) :
5421
				this.empty().each( function() {
5422
					if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
5423
						this.textContent = value;
5424
					}
5425
				} );
5426
		}, null, value, arguments.length );
5427
	},
5428
5429
	append: function() {
5430
		return domManip( this, arguments, function( elem ) {
5431
			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
5432
				var target = manipulationTarget( this, elem );
5433
				target.appendChild( elem );
5434
			}
5435
		} );
5436
	},
5437
5438
	prepend: function() {
5439
		return domManip( this, arguments, function( elem ) {
5440
			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
5441
				var target = manipulationTarget( this, elem );
5442
				target.insertBefore( elem, target.firstChild );
5443
			}
5444
		} );
5445
	},
5446
5447
	before: function() {
5448
		return domManip( this, arguments, function( elem ) {
5449
			if ( this.parentNode ) {
5450
				this.parentNode.insertBefore( elem, this );
5451
			}
5452
		} );
5453
	},
5454
5455
	after: function() {
5456
		return domManip( this, arguments, function( elem ) {
5457
			if ( this.parentNode ) {
5458
				this.parentNode.insertBefore( elem, this.nextSibling );
5459
			}
5460
		} );
5461
	},
5462
5463
	empty: function() {
5464
		var elem,
5465
			i = 0;
5466
5467
		for ( ; ( elem = this[ i ] ) != null; i++ ) {
5468
			if ( elem.nodeType === 1 ) {
5469
5470
				// Prevent memory leaks
5471
				jQuery.cleanData( getAll( elem, false ) );
5472
5473
				// Remove any remaining nodes
5474
				elem.textContent = "";
5475
			}
5476
		}
5477
5478
		return this;
5479
	},
5480
5481
	clone: function( dataAndEvents, deepDataAndEvents ) {
5482
		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
5483
		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
5484
5485
		return this.map( function() {
5486
			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
5487
		} );
5488
	},
5489
5490
	html: function( value ) {
5491
		return access( this, function( value ) {
5492
			var elem = this[ 0 ] || {},
5493
				i = 0,
5494
				l = this.length;
5495
5496
			if ( value === undefined && elem.nodeType === 1 ) {
5497
				return elem.innerHTML;
5498
			}
5499
5500
			// See if we can take a shortcut and just use innerHTML
5501
			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
5502
				!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
5503
5504
				value = jQuery.htmlPrefilter( value );
5505
5506
				try {
5507
					for ( ; i < l; i++ ) {
5508
						elem = this[ i ] || {};
5509
5510
						// Remove element nodes and prevent memory leaks
5511
						if ( elem.nodeType === 1 ) {
5512
							jQuery.cleanData( getAll( elem, false ) );
5513
							elem.innerHTML = value;
5514
						}
5515
					}
5516
5517
					elem = 0;
5518
5519
				// If using innerHTML throws an exception, use the fallback method
5520
				} catch ( e ) {}
5521
			}
5522
5523
			if ( elem ) {
5524
				this.empty().append( value );
5525
			}
5526
		}, null, value, arguments.length );
5527
	},
5528
5529
	replaceWith: function() {
5530
		var ignored = [];
5531
5532
		// Make the changes, replacing each non-ignored context element with the new content
5533
		return domManip( this, arguments, function( elem ) {
5534
			var parent = this.parentNode;
5535
5536
			if ( jQuery.inArray( this, ignored ) < 0 ) {
5537
				jQuery.cleanData( getAll( this ) );
5538
				if ( parent ) {
5539
					parent.replaceChild( elem, this );
5540
				}
5541
			}
5542
5543
		// Force callback invocation
5544
		}, ignored );
5545
	}
5546
} );
5547
5548
jQuery.each( {
5549
	appendTo: "append",
5550
	prependTo: "prepend",
5551
	insertBefore: "before",
5552
	insertAfter: "after",
5553
	replaceAll: "replaceWith"
5554
}, function( name, original ) {
5555
	jQuery.fn[ name ] = function( selector ) {
5556
		var elems,
5557
			ret = [],
5558
			insert = jQuery( selector ),
5559
			last = insert.length - 1,
5560
			i = 0;
5561
5562
		for ( ; i <= last; i++ ) {
5563
			elems = i === last ? this : this.clone( true );
5564
			jQuery( insert[ i ] )[ original ]( elems );
5565
5566
			// Support: QtWebKit
5567
			// .get() because push.apply(_, arraylike) throws
5568
			push.apply( ret, elems.get() );
5569
		}
5570
5571
		return this.pushStack( ret );
5572
	};
5573
} );
5574
5575
5576
var iframe,
5577
	elemdisplay = {
5578
5579
		// Support: Firefox
5580
		// We have to pre-define these values for FF (#10227)
5581
		HTML: "block",
5582
		BODY: "block"
5583
	};
5584
5585
/**
5586
 * Retrieve the actual display of a element
5587
 * @param {String} name nodeName of the element
5588
 * @param {Object} doc Document object
5589
 */
5590
5591
// Called only from within defaultDisplay
5592
function actualDisplay( name, doc ) {
5593
	var elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
5594
5595
		display = jQuery.css( elem[ 0 ], "display" );
5596
5597
	// We don't have any data stored on the element,
5598
	// so use "detach" method as fast way to get rid of the element
5599
	elem.detach();
5600
5601
	return display;
5602
}
5603
5604
/**
5605
 * Try to determine the default display value of an element
5606
 * @param {String} nodeName
5607
 */
5608
function defaultDisplay( nodeName ) {
5609
	var doc = document,
5610
		display = elemdisplay[ nodeName ];
5611
5612
	if ( !display ) {
5613
		display = actualDisplay( nodeName, doc );
5614
5615
		// If the simple way fails, read from inside an iframe
5616
		if ( display === "none" || !display ) {
5617
5618
			// Use the already-created iframe if possible
5619
			iframe = ( iframe || jQuery( "<iframe frameborder='0' width='0' height='0'/>" ) )
5620
				.appendTo( doc.documentElement );
5621
5622
			// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
5623
			doc = iframe[ 0 ].contentDocument;
5624
5625
			// Support: IE
5626
			doc.write();
5627
			doc.close();
5628
5629
			display = actualDisplay( nodeName, doc );
5630
			iframe.detach();
5631
		}
5632
5633
		// Store the correct default display
5634
		elemdisplay[ nodeName ] = display;
5635
	}
5636
5637
	return display;
5638
}
5639
var rmargin = ( /^margin/ );
5640
5641
var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
5642
5643
var getStyles = function( elem ) {
5644
5645
		// Support: IE<=11+, Firefox<=30+ (#15098, #14150)
5646
		// IE throws on elements created in popups
5647
		// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
5648
		var view = elem.ownerDocument.defaultView;
5649
5650
		if ( !view || !view.opener ) {
5651
			view = window;
5652
		}
5653
5654
		return view.getComputedStyle( elem );
5655
	};
5656
5657
var swap = function( elem, options, callback, args ) {
5658
	var ret, name,
5659
		old = {};
5660
5661
	// Remember the old values, and insert the new ones
5662
	for ( name in options ) {
5663
		old[ name ] = elem.style[ name ];
5664
		elem.style[ name ] = options[ name ];
5665
	}
5666
5667
	ret = callback.apply( elem, args || [] );
5668
5669
	// Revert the old values
5670
	for ( name in options ) {
5671
		elem.style[ name ] = old[ name ];
5672
	}
5673
5674
	return ret;
5675
};
5676
5677
5678
var documentElement = document.documentElement;
5679
5680
5681
5682
( function() {
5683
	var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,
5684
		container = document.createElement( "div" ),
5685
		div = document.createElement( "div" );
5686
5687
	// Finish early in limited (non-browser) environments
5688
	if ( !div.style ) {
5689
		return;
5690
	}
5691
5692
	// Support: IE9-11+
5693
	// Style of cloned element affects source element cloned (#8908)
5694
	div.style.backgroundClip = "content-box";
5695
	div.cloneNode( true ).style.backgroundClip = "";
5696
	support.clearCloneStyle = div.style.backgroundClip === "content-box";
5697
5698
	container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
5699
		"padding:0;margin-top:1px;position:absolute";
5700
	container.appendChild( div );
5701
5702
	// Executing both pixelPosition & boxSizingReliable tests require only one layout
5703
	// so they're executed at the same time to save the second computation.
5704
	function computeStyleTests() {
5705
		div.style.cssText =
5706
5707
			// Support: Firefox<29, Android 2.3
5708
			// Vendor-prefix box-sizing
5709
			"-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;" +
5710
			"position:relative;display:block;" +
5711
			"margin:auto;border:1px;padding:1px;" +
5712
			"top:1%;width:50%";
5713
		div.innerHTML = "";
5714
		documentElement.appendChild( container );
5715
5716
		var divStyle = window.getComputedStyle( div );
5717
		pixelPositionVal = divStyle.top !== "1%";
5718
		reliableMarginLeftVal = divStyle.marginLeft === "2px";
5719
		boxSizingReliableVal = divStyle.width === "4px";
5720
5721
		// Support: Android 4.0 - 4.3 only
5722
		// Some styles come back with percentage values, even though they shouldn't
5723
		div.style.marginRight = "50%";
5724
		pixelMarginRightVal = divStyle.marginRight === "4px";
5725
5726
		documentElement.removeChild( container );
5727
	}
5728
5729
	jQuery.extend( support, {
5730
		pixelPosition: function() {
5731
5732
			// This test is executed only once but we still do memoizing
5733
			// since we can use the boxSizingReliable pre-computing.
5734
			// No need to check if the test was already performed, though.
5735
			computeStyleTests();
5736
			return pixelPositionVal;
5737
		},
5738
		boxSizingReliable: function() {
5739
			if ( boxSizingReliableVal == null ) {
5740
				computeStyleTests();
5741
			}
5742
			return boxSizingReliableVal;
5743
		},
5744
		pixelMarginRight: function() {
5745
5746
			// Support: Android 4.0-4.3
5747
			// We're checking for boxSizingReliableVal here instead of pixelMarginRightVal
5748
			// since that compresses better and they're computed together anyway.
5749
			if ( boxSizingReliableVal == null ) {
5750
				computeStyleTests();
5751
			}
5752
			return pixelMarginRightVal;
5753
		},
5754
		reliableMarginLeft: function() {
5755
5756
			// Support: IE <=8 only, Android 4.0 - 4.3 only, Firefox <=3 - 37
5757
			if ( boxSizingReliableVal == null ) {
5758
				computeStyleTests();
5759
			}
5760
			return reliableMarginLeftVal;
5761
		},
5762
		reliableMarginRight: function() {
5763
5764
			// Support: Android 2.3
5765
			// Check if div with explicit width and no margin-right incorrectly
5766
			// gets computed margin-right based on width of container. (#3333)
5767
			// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
5768
			// This support function is only executed once so no memoizing is needed.
5769
			var ret,
5770
				marginDiv = div.appendChild( document.createElement( "div" ) );
5771
5772
			// Reset CSS: box-sizing; display; margin; border; padding
5773
			marginDiv.style.cssText = div.style.cssText =
5774
5775
				// Support: Android 2.3
5776
				// Vendor-prefix box-sizing
5777
				"-webkit-box-sizing:content-box;box-sizing:content-box;" +
5778
				"display:block;margin:0;border:0;padding:0";
5779
			marginDiv.style.marginRight = marginDiv.style.width = "0";
5780
			div.style.width = "1px";
5781
			documentElement.appendChild( container );
5782
5783
			ret = !parseFloat( window.getComputedStyle( marginDiv ).marginRight );
5784
5785
			documentElement.removeChild( container );
5786
			div.removeChild( marginDiv );
5787
5788
			return ret;
5789
		}
5790
	} );
5791
} )();
5792
5793
5794
function curCSS( elem, name, computed ) {
5795
	var width, minWidth, maxWidth, ret,
5796
		style = elem.style;
5797
5798
	computed = computed || getStyles( elem );
5799
	ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined;
5800
5801
	// Support: Opera 12.1x only
5802
	// Fall back to style even without computed
5803
	// computed is undefined for elems on document fragments
5804
	if ( ( ret === "" || ret === undefined ) && !jQuery.contains( elem.ownerDocument, elem ) ) {
5805
		ret = jQuery.style( elem, name );
5806
	}
5807
5808
	// Support: IE9
5809
	// getPropertyValue is only needed for .css('filter') (#12537)
5810
	if ( computed ) {
5811
5812
		// A tribute to the "awesome hack by Dean Edwards"
5813
		// Android Browser returns percentage for some values,
5814
		// but width seems to be reliably pixels.
5815
		// This is against the CSSOM draft spec:
5816
		// http://dev.w3.org/csswg/cssom/#resolved-values
5817
		if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {
5818
5819
			// Remember the original values
5820
			width = style.width;
5821
			minWidth = style.minWidth;
5822
			maxWidth = style.maxWidth;
5823
5824
			// Put in the new values to get a computed value out
5825
			style.minWidth = style.maxWidth = style.width = ret;
5826
			ret = computed.width;
5827
5828
			// Revert the changed values
5829
			style.width = width;
5830
			style.minWidth = minWidth;
5831
			style.maxWidth = maxWidth;
5832
		}
5833
	}
5834
5835
	return ret !== undefined ?
5836
5837
		// Support: IE9-11+
5838
		// IE returns zIndex value as an integer.
5839
		ret + "" :
5840
		ret;
5841
}
5842
5843
5844
function addGetHookIf( conditionFn, hookFn ) {
5845
5846
	// Define the hook, we'll check on the first run if it's really needed.
5847
	return {
5848
		get: function() {
5849
			if ( conditionFn() ) {
5850
5851
				// Hook not needed (or it's not possible to use it due
5852
				// to missing dependency), remove it.
5853
				delete this.get;
5854
				return;
5855
			}
5856
5857
			// Hook needed; redefine it so that the support test is not executed again.
5858
			return ( this.get = hookFn ).apply( this, arguments );
5859
		}
5860
	};
5861
}
5862
5863
5864
var
5865
5866
	// Swappable if display is none or starts with table
5867
	// except "table", "table-cell", or "table-caption"
5868
	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
5869
	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
5870
5871
	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
5872
	cssNormalTransform = {
5873
		letterSpacing: "0",
5874
		fontWeight: "400"
5875
	},
5876
5877
	cssPrefixes = [ "Webkit", "O", "Moz", "ms" ],
5878
	emptyStyle = document.createElement( "div" ).style;
5879
5880
// Return a css property mapped to a potentially vendor prefixed property
5881
function vendorPropName( name ) {
5882
5883
	// Shortcut for names that are not vendor prefixed
5884
	if ( name in emptyStyle ) {
5885
		return name;
5886
	}
5887
5888
	// Check for vendor prefixed names
5889
	var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
5890
		i = cssPrefixes.length;
5891
5892
	while ( i-- ) {
5893
		name = cssPrefixes[ i ] + capName;
5894
		if ( name in emptyStyle ) {
5895
			return name;
5896
		}
5897
	}
5898
}
5899
5900
function setPositiveNumber( elem, value, subtract ) {
5901
5902
	// Any relative (+/-) values have already been
5903
	// normalized at this point
5904
	var matches = rcssNum.exec( value );
5905
	return matches ?
5906
5907
		// Guard against undefined "subtract", e.g., when used as in cssHooks
5908
		Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
5909
		value;
5910
}
5911
5912
function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
5913
	var i = extra === ( isBorderBox ? "border" : "content" ) ?
5914
5915
		// If we already have the right measurement, avoid augmentation
5916
		4 :
5917
5918
		// Otherwise initialize for horizontal or vertical properties
5919
		name === "width" ? 1 : 0,
5920
5921
		val = 0;
5922
5923
	for ( ; i < 4; i += 2 ) {
5924
5925
		// Both box models exclude margin, so add it if we want it
5926
		if ( extra === "margin" ) {
5927
			val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
5928
		}
5929
5930
		if ( isBorderBox ) {
5931
5932
			// border-box includes padding, so remove it if we want content
5933
			if ( extra === "content" ) {
5934
				val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
5935
			}
5936
5937
			// At this point, extra isn't border nor margin, so remove border
5938
			if ( extra !== "margin" ) {
5939
				val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
5940
			}
5941
		} else {
5942
5943
			// At this point, extra isn't content, so add padding
5944
			val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
5945
5946
			// At this point, extra isn't content nor padding, so add border
5947
			if ( extra !== "padding" ) {
5948
				val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
5949
			}
5950
		}
5951
	}
5952
5953
	return val;
5954
}
5955
5956
function getWidthOrHeight( elem, name, extra ) {
5957
5958
	// Start with offset property, which is equivalent to the border-box value
5959
	var valueIsBorderBox = true,
5960
		val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
5961
		styles = getStyles( elem ),
5962
		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
5963
5964
	// Support: IE11 only
5965
	// In IE 11 fullscreen elements inside of an iframe have
5966
	// 100x too small dimensions (gh-1764).
5967
	if ( document.msFullscreenElement && window.top !== window ) {
5968
5969
		// Support: IE11 only
5970
		// Running getBoundingClientRect on a disconnected node
5971
		// in IE throws an error.
5972
		if ( elem.getClientRects().length ) {
5973
			val = Math.round( elem.getBoundingClientRect()[ name ] * 100 );
5974
		}
5975
	}
5976
5977
	// Some non-html elements return undefined for offsetWidth, so check for null/undefined
5978
	// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
5979
	// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
5980
	if ( val <= 0 || val == null ) {
5981
5982
		// Fall back to computed then uncomputed css if necessary
5983
		val = curCSS( elem, name, styles );
5984
		if ( val < 0 || val == null ) {
5985
			val = elem.style[ name ];
5986
		}
5987
5988
		// Computed unit is not pixels. Stop here and return.
5989
		if ( rnumnonpx.test( val ) ) {
5990
			return val;
5991
		}
5992
5993
		// Check for style in case a browser which returns unreliable values
5994
		// for getComputedStyle silently falls back to the reliable elem.style
5995
		valueIsBorderBox = isBorderBox &&
5996
			( support.boxSizingReliable() || val === elem.style[ name ] );
5997
5998
		// Normalize "", auto, and prepare for extra
5999
		val = parseFloat( val ) || 0;
6000
	}
6001
6002
	// Use the active box-sizing model to add/subtract irrelevant styles
6003
	return ( val +
6004
		augmentWidthOrHeight(
6005
			elem,
6006
			name,
6007
			extra || ( isBorderBox ? "border" : "content" ),
6008
			valueIsBorderBox,
6009
			styles
6010
		)
6011
	) + "px";
6012
}
6013
6014
function showHide( elements, show ) {
6015
	var display, elem, hidden,
6016
		values = [],
6017
		index = 0,
6018
		length = elements.length;
6019
6020
	for ( ; index < length; index++ ) {
6021
		elem = elements[ index ];
6022
		if ( !elem.style ) {
6023
			continue;
6024
		}
6025
6026
		values[ index ] = dataPriv.get( elem, "olddisplay" );
6027
		display = elem.style.display;
6028
		if ( show ) {
6029
6030
			// Reset the inline display of this element to learn if it is
6031
			// being hidden by cascaded rules or not
6032
			if ( !values[ index ] && display === "none" ) {
6033
				elem.style.display = "";
6034
			}
6035
6036
			// Set elements which have been overridden with display: none
6037
			// in a stylesheet to whatever the default browser style is
6038
			// for such an element
6039
			if ( elem.style.display === "" && isHidden( elem ) ) {
6040
				values[ index ] = dataPriv.access(
6041
					elem,
6042
					"olddisplay",
6043
					defaultDisplay( elem.nodeName )
6044
				);
6045
			}
6046
		} else {
6047
			hidden = isHidden( elem );
6048
6049
			if ( display !== "none" || !hidden ) {
6050
				dataPriv.set(
6051
					elem,
6052
					"olddisplay",
6053
					hidden ? display : jQuery.css( elem, "display" )
6054
				);
6055
			}
6056
		}
6057
	}
6058
6059
	// Set the display of most of the elements in a second loop
6060
	// to avoid the constant reflow
6061
	for ( index = 0; index < length; index++ ) {
6062
		elem = elements[ index ];
6063
		if ( !elem.style ) {
6064
			continue;
6065
		}
6066
		if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
6067
			elem.style.display = show ? values[ index ] || "" : "none";
6068
		}
6069
	}
6070
6071
	return elements;
6072
}
6073
6074
jQuery.extend( {
6075
6076
	// Add in style property hooks for overriding the default
6077
	// behavior of getting and setting a style property
6078
	cssHooks: {
6079
		opacity: {
6080
			get: function( elem, computed ) {
6081
				if ( computed ) {
6082
6083
					// We should always get a number back from opacity
6084
					var ret = curCSS( elem, "opacity" );
6085
					return ret === "" ? "1" : ret;
6086
				}
6087
			}
6088
		}
6089
	},
6090
6091
	// Don't automatically add "px" to these possibly-unitless properties
6092
	cssNumber: {
6093
		"animationIterationCount": true,
6094
		"columnCount": true,
6095
		"fillOpacity": true,
6096
		"flexGrow": true,
6097
		"flexShrink": true,
6098
		"fontWeight": true,
6099
		"lineHeight": true,
6100
		"opacity": true,
6101
		"order": true,
6102
		"orphans": true,
6103
		"widows": true,
6104
		"zIndex": true,
6105
		"zoom": true
6106
	},
6107
6108
	// Add in properties whose names you wish to fix before
6109
	// setting or getting the value
6110
	cssProps: {
6111
		"float": "cssFloat"
6112
	},
6113
6114
	// Get and set the style property on a DOM Node
6115
	style: function( elem, name, value, extra ) {
6116
6117
		// Don't set styles on text and comment nodes
6118
		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
6119
			return;
6120
		}
6121
6122
		// Make sure that we're working with the right name
6123
		var ret, type, hooks,
6124
			origName = jQuery.camelCase( name ),
6125
			style = elem.style;
6126
6127
		name = jQuery.cssProps[ origName ] ||
6128
			( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );
6129
6130
		// Gets hook for the prefixed version, then unprefixed version
6131
		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6132
6133
		// Check if we're setting a value
6134
		if ( value !== undefined ) {
6135
			type = typeof value;
6136
6137
			// Convert "+=" or "-=" to relative numbers (#7345)
6138
			if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
6139
				value = adjustCSS( elem, name, ret );
6140
6141
				// Fixes bug #9237
6142
				type = "number";
6143
			}
6144
6145
			// Make sure that null and NaN values aren't set (#7116)
6146
			if ( value == null || value !== value ) {
6147
				return;
6148
			}
6149
6150
			// If a number was passed in, add the unit (except for certain CSS properties)
6151
			if ( type === "number" ) {
6152
				value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
6153
			}
6154
6155
			// Support: IE9-11+
6156
			// background-* props affect original clone's values
6157
			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
6158
				style[ name ] = "inherit";
6159
			}
6160
6161
			// If a hook was provided, use that value, otherwise just set the specified value
6162
			if ( !hooks || !( "set" in hooks ) ||
6163
				( value = hooks.set( elem, value, extra ) ) !== undefined ) {
6164
6165
				style[ name ] = value;
6166
			}
6167
6168
		} else {
6169
6170
			// If a hook was provided get the non-computed value from there
6171
			if ( hooks && "get" in hooks &&
6172
				( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
6173
6174
				return ret;
6175
			}
6176
6177
			// Otherwise just get the value from the style object
6178
			return style[ name ];
6179
		}
6180
	},
6181
6182
	css: function( elem, name, extra, styles ) {
6183
		var val, num, hooks,
6184
			origName = jQuery.camelCase( name );
6185
6186
		// Make sure that we're working with the right name
6187
		name = jQuery.cssProps[ origName ] ||
6188
			( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );
6189
6190
		// Try prefixed name followed by the unprefixed name
6191
		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6192
6193
		// If a hook was provided get the computed value from there
6194
		if ( hooks && "get" in hooks ) {
6195
			val = hooks.get( elem, true, extra );
6196
		}
6197
6198
		// Otherwise, if a way to get the computed value exists, use that
6199
		if ( val === undefined ) {
6200
			val = curCSS( elem, name, styles );
6201
		}
6202
6203
		// Convert "normal" to computed value
6204
		if ( val === "normal" && name in cssNormalTransform ) {
6205
			val = cssNormalTransform[ name ];
6206
		}
6207
6208
		// Make numeric if forced or a qualifier was provided and val looks numeric
6209
		if ( extra === "" || extra ) {
6210
			num = parseFloat( val );
6211
			return extra === true || isFinite( num ) ? num || 0 : val;
6212
		}
6213
		return val;
6214
	}
6215
} );
6216
6217
jQuery.each( [ "height", "width" ], function( i, name ) {
6218
	jQuery.cssHooks[ name ] = {
6219
		get: function( elem, computed, extra ) {
6220
			if ( computed ) {
6221
6222
				// Certain elements can have dimension info if we invisibly show them
6223
				// but it must have a current display style that would benefit
6224
				return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
6225
					elem.offsetWidth === 0 ?
6226
						swap( elem, cssShow, function() {
6227
							return getWidthOrHeight( elem, name, extra );
6228
						} ) :
6229
						getWidthOrHeight( elem, name, extra );
6230
			}
6231
		},
6232
6233
		set: function( elem, value, extra ) {
6234
			var matches,
6235
				styles = extra && getStyles( elem ),
6236
				subtract = extra && augmentWidthOrHeight(
6237
					elem,
6238
					name,
6239
					extra,
6240
					jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
6241
					styles
6242
				);
6243
6244
			// Convert to pixels if value adjustment is needed
6245
			if ( subtract && ( matches = rcssNum.exec( value ) ) &&
6246
				( matches[ 3 ] || "px" ) !== "px" ) {
6247
6248
				elem.style[ name ] = value;
6249
				value = jQuery.css( elem, name );
6250
			}
6251
6252
			return setPositiveNumber( elem, value, subtract );
6253
		}
6254
	};
6255
} );
6256
6257
jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
6258
	function( elem, computed ) {
6259
		if ( computed ) {
6260
			return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
6261
				elem.getBoundingClientRect().left -
6262
					swap( elem, { marginLeft: 0 }, function() {
6263
						return elem.getBoundingClientRect().left;
6264
					} )
6265
				) + "px";
6266
		}
6267
	}
6268
);
6269
6270
// Support: Android 2.3
6271
jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,
6272
	function( elem, computed ) {
6273
		if ( computed ) {
6274
			return swap( elem, { "display": "inline-block" },
6275
				curCSS, [ elem, "marginRight" ] );
6276
		}
6277
	}
6278
);
6279
6280
// These hooks are used by animate to expand properties
6281
jQuery.each( {
6282
	margin: "",
6283
	padding: "",
6284
	border: "Width"
6285
}, function( prefix, suffix ) {
6286
	jQuery.cssHooks[ prefix + suffix ] = {
6287
		expand: function( value ) {
6288
			var i = 0,
6289
				expanded = {},
6290
6291
				// Assumes a single number if not a string
6292
				parts = typeof value === "string" ? value.split( " " ) : [ value ];
6293
6294
			for ( ; i < 4; i++ ) {
6295
				expanded[ prefix + cssExpand[ i ] + suffix ] =
6296
					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
6297
			}
6298
6299
			return expanded;
6300
		}
6301
	};
6302
6303
	if ( !rmargin.test( prefix ) ) {
6304
		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
6305
	}
6306
} );
6307
6308
jQuery.fn.extend( {
6309
	css: function( name, value ) {
6310
		return access( this, function( elem, name, value ) {
6311
			var styles, len,
6312
				map = {},
6313
				i = 0;
6314
6315
			if ( jQuery.isArray( name ) ) {
6316
				styles = getStyles( elem );
6317
				len = name.length;
6318
6319
				for ( ; i < len; i++ ) {
6320
					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
6321
				}
6322
6323
				return map;
6324
			}
6325
6326
			return value !== undefined ?
6327
				jQuery.style( elem, name, value ) :
6328
				jQuery.css( elem, name );
6329
		}, name, value, arguments.length > 1 );
6330
	},
6331
	show: function() {
6332
		return showHide( this, true );
6333
	},
6334
	hide: function() {
6335
		return showHide( this );
6336
	},
6337
	toggle: function( state ) {
6338
		if ( typeof state === "boolean" ) {
6339
			return state ? this.show() : this.hide();
6340
		}
6341
6342
		return this.each( function() {
6343
			if ( isHidden( this ) ) {
6344
				jQuery( this ).show();
6345
			} else {
6346
				jQuery( this ).hide();
6347
			}
6348
		} );
6349
	}
6350
} );
6351
6352
6353
function Tween( elem, options, prop, end, easing ) {
6354
	return new Tween.prototype.init( elem, options, prop, end, easing );
6355
}
6356
jQuery.Tween = Tween;
6357
6358
Tween.prototype = {
6359
	constructor: Tween,
6360
	init: function( elem, options, prop, end, easing, unit ) {
6361
		this.elem = elem;
6362
		this.prop = prop;
6363
		this.easing = easing || jQuery.easing._default;
6364
		this.options = options;
6365
		this.start = this.now = this.cur();
6366
		this.end = end;
6367
		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
6368
	},
6369
	cur: function() {
6370
		var hooks = Tween.propHooks[ this.prop ];
6371
6372
		return hooks && hooks.get ?
6373
			hooks.get( this ) :
6374
			Tween.propHooks._default.get( this );
6375
	},
6376
	run: function( percent ) {
6377
		var eased,
6378
			hooks = Tween.propHooks[ this.prop ];
6379
6380
		if ( this.options.duration ) {
6381
			this.pos = eased = jQuery.easing[ this.easing ](
6382
				percent, this.options.duration * percent, 0, 1, this.options.duration
6383
			);
6384
		} else {
6385
			this.pos = eased = percent;
6386
		}
6387
		this.now = ( this.end - this.start ) * eased + this.start;
6388
6389
		if ( this.options.step ) {
6390
			this.options.step.call( this.elem, this.now, this );
6391
		}
6392
6393
		if ( hooks && hooks.set ) {
6394
			hooks.set( this );
6395
		} else {
6396
			Tween.propHooks._default.set( this );
6397
		}
6398
		return this;
6399
	}
6400
};
6401
6402
Tween.prototype.init.prototype = Tween.prototype;
6403
6404
Tween.propHooks = {
6405
	_default: {
6406
		get: function( tween ) {
6407
			var result;
6408
6409
			// Use a property on the element directly when it is not a DOM element,
6410
			// or when there is no matching style property that exists.
6411
			if ( tween.elem.nodeType !== 1 ||
6412
				tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
6413
				return tween.elem[ tween.prop ];
6414
			}
6415
6416
			// Passing an empty string as a 3rd parameter to .css will automatically
6417
			// attempt a parseFloat and fallback to a string if the parse fails.
6418
			// Simple values such as "10px" are parsed to Float;
6419
			// complex values such as "rotate(1rad)" are returned as-is.
6420
			result = jQuery.css( tween.elem, tween.prop, "" );
6421
6422
			// Empty strings, null, undefined and "auto" are converted to 0.
6423
			return !result || result === "auto" ? 0 : result;
6424
		},
6425
		set: function( tween ) {
6426
6427
			// Use step hook for back compat.
6428
			// Use cssHook if its there.
6429
			// Use .style if available and use plain properties where available.
6430
			if ( jQuery.fx.step[ tween.prop ] ) {
6431
				jQuery.fx.step[ tween.prop ]( tween );
6432
			} else if ( tween.elem.nodeType === 1 &&
6433
				( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
6434
					jQuery.cssHooks[ tween.prop ] ) ) {
6435
				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
6436
			} else {
6437
				tween.elem[ tween.prop ] = tween.now;
6438
			}
6439
		}
6440
	}
6441
};
6442
6443
// Support: IE9
6444
// Panic based approach to setting things on disconnected nodes
6445
Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
6446
	set: function( tween ) {
6447
		if ( tween.elem.nodeType && tween.elem.parentNode ) {
6448
			tween.elem[ tween.prop ] = tween.now;
6449
		}
6450
	}
6451
};
6452
6453
jQuery.easing = {
6454
	linear: function( p ) {
6455
		return p;
6456
	},
6457
	swing: function( p ) {
6458
		return 0.5 - Math.cos( p * Math.PI ) / 2;
6459
	},
6460
	_default: "swing"
6461
};
6462
6463
jQuery.fx = Tween.prototype.init;
6464
6465
// Back Compat <1.8 extension point
6466
jQuery.fx.step = {};
6467
6468
6469
6470
6471
var
6472
	fxNow, timerId,
6473
	rfxtypes = /^(?:toggle|show|hide)$/,
6474
	rrun = /queueHooks$/;
6475
6476
// Animations created synchronously will run synchronously
6477
function createFxNow() {
6478
	window.setTimeout( function() {
6479
		fxNow = undefined;
6480
	} );
6481
	return ( fxNow = jQuery.now() );
6482
}
6483
6484
// Generate parameters to create a standard animation
6485
function genFx( type, includeWidth ) {
6486
	var which,
6487
		i = 0,
6488
		attrs = { height: type };
6489
6490
	// If we include width, step value is 1 to do all cssExpand values,
6491
	// otherwise step value is 2 to skip over Left and Right
6492
	includeWidth = includeWidth ? 1 : 0;
6493
	for ( ; i < 4 ; i += 2 - includeWidth ) {
6494
		which = cssExpand[ i ];
6495
		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
6496
	}
6497
6498
	if ( includeWidth ) {
6499
		attrs.opacity = attrs.width = type;
6500
	}
6501
6502
	return attrs;
6503
}
6504
6505
function createTween( value, prop, animation ) {
6506
	var tween,
6507
		collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
6508
		index = 0,
6509
		length = collection.length;
6510
	for ( ; index < length; index++ ) {
6511
		if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
6512
6513
			// We're done with this property
6514
			return tween;
6515
		}
6516
	}
6517
}
6518
6519
function defaultPrefilter( elem, props, opts ) {
6520
	/* jshint validthis: true */
6521
	var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
6522
		anim = this,
6523
		orig = {},
6524
		style = elem.style,
6525
		hidden = elem.nodeType && isHidden( elem ),
6526
		dataShow = dataPriv.get( elem, "fxshow" );
6527
6528
	// Handle queue: false promises
6529
	if ( !opts.queue ) {
6530
		hooks = jQuery._queueHooks( elem, "fx" );
6531
		if ( hooks.unqueued == null ) {
6532
			hooks.unqueued = 0;
6533
			oldfire = hooks.empty.fire;
6534
			hooks.empty.fire = function() {
6535
				if ( !hooks.unqueued ) {
6536
					oldfire();
6537
				}
6538
			};
6539
		}
6540
		hooks.unqueued++;
6541
6542
		anim.always( function() {
6543
6544
			// Ensure the complete handler is called before this completes
6545
			anim.always( function() {
6546
				hooks.unqueued--;
6547
				if ( !jQuery.queue( elem, "fx" ).length ) {
6548
					hooks.empty.fire();
6549
				}
6550
			} );
6551
		} );
6552
	}
6553
6554
	// Height/width overflow pass
6555
	if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
6556
6557
		// Make sure that nothing sneaks out
6558
		// Record all 3 overflow attributes because IE9-10 do not
6559
		// change the overflow attribute when overflowX and
6560
		// overflowY are set to the same value
6561
		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
6562
6563
		// Set display property to inline-block for height/width
6564
		// animations on inline elements that are having width/height animated
6565
		display = jQuery.css( elem, "display" );
6566
6567
		// Test default display if display is currently "none"
6568
		checkDisplay = display === "none" ?
6569
			dataPriv.get( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display;
6570
6571
		if ( checkDisplay === "inline" && jQuery.css( elem, "float" ) === "none" ) {
6572
			style.display = "inline-block";
6573
		}
6574
	}
6575
6576
	if ( opts.overflow ) {
6577
		style.overflow = "hidden";
6578
		anim.always( function() {
6579
			style.overflow = opts.overflow[ 0 ];
6580
			style.overflowX = opts.overflow[ 1 ];
6581
			style.overflowY = opts.overflow[ 2 ];
6582
		} );
6583
	}
6584
6585
	// show/hide pass
6586
	for ( prop in props ) {
6587
		value = props[ prop ];
6588
		if ( rfxtypes.exec( value ) ) {
6589
			delete props[ prop ];
6590
			toggle = toggle || value === "toggle";
6591
			if ( value === ( hidden ? "hide" : "show" ) ) {
6592
6593
				// If there is dataShow left over from a stopped hide or show
6594
				// and we are going to proceed with show, we should pretend to be hidden
6595
				if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
6596
					hidden = true;
6597
				} else {
6598
					continue;
6599
				}
6600
			}
6601
			orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
6602
6603
		// Any non-fx value stops us from restoring the original display value
6604
		} else {
6605
			display = undefined;
6606
		}
6607
	}
6608
6609
	if ( !jQuery.isEmptyObject( orig ) ) {
6610
		if ( dataShow ) {
6611
			if ( "hidden" in dataShow ) {
6612
				hidden = dataShow.hidden;
6613
			}
6614
		} else {
6615
			dataShow = dataPriv.access( elem, "fxshow", {} );
6616
		}
6617
6618
		// Store state if its toggle - enables .stop().toggle() to "reverse"
6619
		if ( toggle ) {
6620
			dataShow.hidden = !hidden;
6621
		}
6622
		if ( hidden ) {
6623
			jQuery( elem ).show();
6624
		} else {
6625
			anim.done( function() {
6626
				jQuery( elem ).hide();
6627
			} );
6628
		}
6629
		anim.done( function() {
6630
			var prop;
6631
6632
			dataPriv.remove( elem, "fxshow" );
6633
			for ( prop in orig ) {
6634
				jQuery.style( elem, prop, orig[ prop ] );
6635
			}
6636
		} );
6637
		for ( prop in orig ) {
6638
			tween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
6639
6640
			if ( !( prop in dataShow ) ) {
6641
				dataShow[ prop ] = tween.start;
6642
				if ( hidden ) {
6643
					tween.end = tween.start;
6644
					tween.start = prop === "width" || prop === "height" ? 1 : 0;
6645
				}
6646
			}
6647
		}
6648
6649
	// If this is a noop like .hide().hide(), restore an overwritten display value
6650
	} else if ( ( display === "none" ? defaultDisplay( elem.nodeName ) : display ) === "inline" ) {
6651
		style.display = display;
6652
	}
6653
}
6654
6655
function propFilter( props, specialEasing ) {
6656
	var index, name, easing, value, hooks;
6657
6658
	// camelCase, specialEasing and expand cssHook pass
6659
	for ( index in props ) {
6660
		name = jQuery.camelCase( index );
6661
		easing = specialEasing[ name ];
6662
		value = props[ index ];
6663
		if ( jQuery.isArray( value ) ) {
6664
			easing = value[ 1 ];
6665
			value = props[ index ] = value[ 0 ];
6666
		}
6667
6668
		if ( index !== name ) {
6669
			props[ name ] = value;
6670
			delete props[ index ];
6671
		}
6672
6673
		hooks = jQuery.cssHooks[ name ];
6674
		if ( hooks && "expand" in hooks ) {
6675
			value = hooks.expand( value );
6676
			delete props[ name ];
6677
6678
			// Not quite $.extend, this won't overwrite existing keys.
6679
			// Reusing 'index' because we have the correct "name"
6680
			for ( index in value ) {
6681
				if ( !( index in props ) ) {
6682
					props[ index ] = value[ index ];
6683
					specialEasing[ index ] = easing;
6684
				}
6685
			}
6686
		} else {
6687
			specialEasing[ name ] = easing;
6688
		}
6689
	}
6690
}
6691
6692
function Animation( elem, properties, options ) {
6693
	var result,
6694
		stopped,
6695
		index = 0,
6696
		length = Animation.prefilters.length,
6697
		deferred = jQuery.Deferred().always( function() {
6698
6699
			// Don't match elem in the :animated selector
6700
			delete tick.elem;
6701
		} ),
6702
		tick = function() {
6703
			if ( stopped ) {
6704
				return false;
6705
			}
6706
			var currentTime = fxNow || createFxNow(),
6707
				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
6708
6709
				// Support: Android 2.3
6710
				// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
6711
				temp = remaining / animation.duration || 0,
6712
				percent = 1 - temp,
6713
				index = 0,
6714
				length = animation.tweens.length;
6715
6716
			for ( ; index < length ; index++ ) {
6717
				animation.tweens[ index ].run( percent );
6718
			}
6719
6720
			deferred.notifyWith( elem, [ animation, percent, remaining ] );
6721
6722
			if ( percent < 1 && length ) {
6723
				return remaining;
6724
			} else {
6725
				deferred.resolveWith( elem, [ animation ] );
6726
				return false;
6727
			}
6728
		},
6729
		animation = deferred.promise( {
6730
			elem: elem,
6731
			props: jQuery.extend( {}, properties ),
6732
			opts: jQuery.extend( true, {
6733
				specialEasing: {},
6734
				easing: jQuery.easing._default
6735
			}, options ),
6736
			originalProperties: properties,
6737
			originalOptions: options,
6738
			startTime: fxNow || createFxNow(),
6739
			duration: options.duration,
6740
			tweens: [],
6741
			createTween: function( prop, end ) {
6742
				var tween = jQuery.Tween( elem, animation.opts, prop, end,
6743
						animation.opts.specialEasing[ prop ] || animation.opts.easing );
6744
				animation.tweens.push( tween );
6745
				return tween;
6746
			},
6747
			stop: function( gotoEnd ) {
6748
				var index = 0,
6749
6750
					// If we are going to the end, we want to run all the tweens
6751
					// otherwise we skip this part
6752
					length = gotoEnd ? animation.tweens.length : 0;
6753
				if ( stopped ) {
6754
					return this;
6755
				}
6756
				stopped = true;
6757
				for ( ; index < length ; index++ ) {
6758
					animation.tweens[ index ].run( 1 );
6759
				}
6760
6761
				// Resolve when we played the last frame; otherwise, reject
6762
				if ( gotoEnd ) {
6763
					deferred.notifyWith( elem, [ animation, 1, 0 ] );
6764
					deferred.resolveWith( elem, [ animation, gotoEnd ] );
6765
				} else {
6766
					deferred.rejectWith( elem, [ animation, gotoEnd ] );
6767
				}
6768
				return this;
6769
			}
6770
		} ),
6771
		props = animation.props;
6772
6773
	propFilter( props, animation.opts.specialEasing );
6774
6775
	for ( ; index < length ; index++ ) {
6776
		result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
6777
		if ( result ) {
6778
			if ( jQuery.isFunction( result.stop ) ) {
6779
				jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
6780
					jQuery.proxy( result.stop, result );
6781
			}
6782
			return result;
6783
		}
6784
	}
6785
6786
	jQuery.map( props, createTween, animation );
6787
6788
	if ( jQuery.isFunction( animation.opts.start ) ) {
6789
		animation.opts.start.call( elem, animation );
6790
	}
6791
6792
	jQuery.fx.timer(
6793
		jQuery.extend( tick, {
6794
			elem: elem,
6795
			anim: animation,
6796
			queue: animation.opts.queue
6797
		} )
6798
	);
6799
6800
	// attach callbacks from options
6801
	return animation.progress( animation.opts.progress )
6802
		.done( animation.opts.done, animation.opts.complete )
6803
		.fail( animation.opts.fail )
6804
		.always( animation.opts.always );
6805
}
6806
6807
jQuery.Animation = jQuery.extend( Animation, {
6808
	tweeners: {
6809
		"*": [ function( prop, value ) {
6810
			var tween = this.createTween( prop, value );
6811
			adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
6812
			return tween;
6813
		} ]
6814
	},
6815
6816
	tweener: function( props, callback ) {
6817
		if ( jQuery.isFunction( props ) ) {
6818
			callback = props;
6819
			props = [ "*" ];
6820
		} else {
6821
			props = props.match( rnotwhite );
6822
		}
6823
6824
		var prop,
6825
			index = 0,
6826
			length = props.length;
6827
6828
		for ( ; index < length ; index++ ) {
6829
			prop = props[ index ];
6830
			Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
6831
			Animation.tweeners[ prop ].unshift( callback );
6832
		}
6833
	},
6834
6835
	prefilters: [ defaultPrefilter ],
6836
6837
	prefilter: function( callback, prepend ) {
6838
		if ( prepend ) {
6839
			Animation.prefilters.unshift( callback );
6840
		} else {
6841
			Animation.prefilters.push( callback );
6842
		}
6843
	}
6844
} );
6845
6846
jQuery.speed = function( speed, easing, fn ) {
6847
	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
6848
		complete: fn || !fn && easing ||
6849
			jQuery.isFunction( speed ) && speed,
6850
		duration: speed,
6851
		easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
6852
	};
6853
6854
	opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ?
6855
		opt.duration : opt.duration in jQuery.fx.speeds ?
6856
			jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
6857
6858
	// Normalize opt.queue - true/undefined/null -> "fx"
6859
	if ( opt.queue == null || opt.queue === true ) {
6860
		opt.queue = "fx";
6861
	}
6862
6863
	// Queueing
6864
	opt.old = opt.complete;
6865
6866
	opt.complete = function() {
6867
		if ( jQuery.isFunction( opt.old ) ) {
6868
			opt.old.call( this );
6869
		}
6870
6871
		if ( opt.queue ) {
6872
			jQuery.dequeue( this, opt.queue );
6873
		}
6874
	};
6875
6876
	return opt;
6877
};
6878
6879
jQuery.fn.extend( {
6880
	fadeTo: function( speed, to, easing, callback ) {
6881
6882
		// Show any hidden elements after setting opacity to 0
6883
		return this.filter( isHidden ).css( "opacity", 0 ).show()
6884
6885
			// Animate to the value specified
6886
			.end().animate( { opacity: to }, speed, easing, callback );
6887
	},
6888
	animate: function( prop, speed, easing, callback ) {