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

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