r5Gr1GMK

1/*!
2 * jQuery JavaScript Library v1.12.3
3 * http://jquery.com/
4 *
5 * Includes Sizzle.js
6 * http://sizzlejs.com/
7 *
8 * Copyright jQuery Foundation and other contributors
9 * Released under the MIT license
10 * http://jquery.org/license
11 *
12 * Date: 2016-04-05T19:16Z
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";
45var deletedIds = [];
46
47var document = window.document;
48
49var slice = deletedIds.slice;
50
51var concat = deletedIds.concat;
52
53var push = deletedIds.push;
54
55var indexOf = deletedIds.indexOf;
56
57var class2type = {};
58
59var toString = class2type.toString;
60
61var hasOwn = class2type.hasOwnProperty;
62
63var support = {};
64
65
66
67var
68	version = "1.12.3",
69
70	// Define a local copy of jQuery
71	jQuery = function( selector, context ) {
72
73		// The jQuery object is actually just the init constructor 'enhanced'
74		// Need init if jQuery is called (just allow error to be thrown if not included)
75		return new jQuery.fn.init( selector, context );
76	},
77
78	// Support: Android<4.1, 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
91jQuery.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
175jQuery.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
244jQuery.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 */
552if ( typeof Symbol === "function" ) {
553	jQuery.fn[ Symbol.iterator ] = deletedIds[ Symbol.iterator ];
554}
555/* jshint ignore: end */
556
557// Populate the class2type map
558jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
559function( i, name ) {
560	class2type[ "[object " + name + "]" ] = name.toLowerCase();
561} );
562
563function 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}
579var 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
592var 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 )
744try {
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
772function 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 */
912function 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 */
930function 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 */
939function 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 */
961function 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 */
976function 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 */
1003function 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 */
1014function 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 */
1025function 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 */
1048function testContext( context ) {
1049	return context && typeof context.getElementsByTagName !== "undefined" && context;
1050}
1051
1052// Expose support vars for convenience
1053support = 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 */
1060isXML = 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 */
1072setDocument = 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
1438Sizzle.matches = function( expr, elements ) {
1439	return Sizzle( expr, null, null, elements );
1440};
1441
1442Sizzle.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
1472Sizzle.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
1480Sizzle.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
1501Sizzle.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 */
1509Sizzle.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 */
1542getText = 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
1573Expr = 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
2082Expr.pseudos["nth"] = Expr.pseudos["eq"];
2083
2084// Add button/input type pseudos
2085for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2086	Expr.pseudos[ i ] = createInputPseudo( i );
2087}
2088for ( i in { submit: true, reset: true } ) {
2089	Expr.pseudos[ i ] = createButtonPseudo( i );
2090}
2091
2092// Easy API for creating new setFilters
2093function setFilters() {}
2094setFilters.prototype = Expr.filters = Expr.pseudos;
2095Expr.setFilters = new setFilters();
2096
2097tokenize = 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
2164function 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
2174function 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
2232function 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
2246function 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
2255function 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
2276function 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
2369function 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
2427function 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
2538compile = 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 */
2577select = 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
2651support.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
2655support.detectDuplicates = !!hasDuplicate;
2656
2657// Initialize against the default document
2658setDocument();
2659
2660// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2661// Detached nodes confoundingly follow *each other*
2662support.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
2670if ( !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")
2683if ( !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
2697if ( !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
2711return Sizzle;
2712
2713})( window );
2714
2715
2716
2717jQuery.find = Sizzle;
2718jQuery.expr = Sizzle.selectors;
2719jQuery.expr[ ":" ] = jQuery.expr.pseudos;
2720jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2721jQuery.text = Sizzle.getText;
2722jQuery.isXMLDoc = Sizzle.isXML;
2723jQuery.contains = Sizzle.contains;
2724
2725
2726
2727var 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
2743var 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
2756var rneedsContext = jQuery.expr.match.needsContext;
2757
2758var rsingleTag = ( /^<([\w-]+)\s*\/?>(?:<\/\1>|)$/ );
2759
2760
2761
2762var risSimple = /^.[^:#\[\.,]*$/;
2763
2764// Implement the identical functionality for filter and not
2765function 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
2794jQuery.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
2808jQuery.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)
2859var 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
2982init.prototype = jQuery.fn;
2983
2984// Initialize central reference
2985rootjQuery = jQuery( document );
2986
2987
2988var 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
2998jQuery.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
3078function sibling( cur, dir ) {
3079	do {
3080		cur = cur[ dir ];
3081	} while ( cur && cur.nodeType !== 1 );
3082
3083	return cur;
3084}
3085
3086jQuery.each( {
3087	parent: function( elem ) {
3088		var parent = elem.parentNode;
3089		return parent && parent.nodeType !== 11 ? parent : null;
3090	},
3091	parents: function( elem ) {
3092		return dir( elem, "parentNode" );
3093	},
3094	parentsUntil: function( elem, i, until ) {
3095		return dir( elem, "parentNode", until );
3096	},
3097	next: function( elem ) {
3098		return sibling( elem, "nextSibling" );
3099	},
3100	prev: function( elem ) {
3101		return sibling( elem, "previousSibling" );
3102	},
3103	nextAll: function( elem ) {
3104		return dir( elem, "nextSibling" );
3105	},
3106	prevAll: function( elem ) {
3107		return dir( elem, "previousSibling" );
3108	},
3109	nextUntil: function( elem, i, until ) {
3110		return dir( elem, "nextSibling", until );
3111	},
3112	prevUntil: function( elem, i, until ) {
3113		return dir( elem, "previousSibling", until );
3114	},
3115	siblings: function( elem ) {
3116		return siblings( ( elem.parentNode || {} ).firstChild, elem );
3117	},
3118	children: function( elem ) {
3119		return siblings( elem.firstChild );
3120	},
3121	contents: function( elem ) {
3122		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} );
3154var rnotwhite = ( /\S+/g );
3155
3156
3157
3158// Convert String-formatted options into Object-formatted ones
3159function 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 */
3189jQuery.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
3384jQuery.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
3537var readyList;
3538
3539jQuery.fn.ready = function( fn ) {
3540
3541	// Add the callback
3542	jQuery.ready.promise().done( fn );
3543
3544	return this;
3545};
3546
3547jQuery.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 */
3595function 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 */
3609function 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
3621jQuery.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		// Support: IE6-10
3629		// Older IE sometimes signals "interactive" too soon
3630		if ( document.readyState === "complete" ||
3631			( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
3632
3633			// Handle it asynchronously to allow scripts the opportunity to delay ready
3634			window.setTimeout( jQuery.ready );
3635
3636		// Standards-based browsers support DOMContentLoaded
3637		} else if ( document.addEventListener ) {
3638
3639			// Use the handy event callback
3640			document.addEventListener( "DOMContentLoaded", completed );
3641
3642			// A fallback to window.onload, that will always work
3643			window.addEventListener( "load", completed );
3644
3645		// If IE event model is used
3646		} else {
3647
3648			// Ensure firing before onload, maybe late but safe also for iframes
3649			document.attachEvent( "onreadystatechange", completed );
3650
3651			// A fallback to window.onload, that will always work
3652			window.attachEvent( "onload", completed );
3653
3654			// If IE and not a frame
3655			// continually check to see if the document is ready
3656			var top = false;
3657
3658			try {
3659				top = window.frameElement == null && document.documentElement;
3660			} catch ( e ) {}
3661
3662			if ( top && top.doScroll ) {
3663				( function doScrollCheck() {
3664					if ( !jQuery.isReady ) {
3665
3666						try {
3667
3668							// Use the trick by Diego Perini
3669							// http://javascript.nwbox.com/IEContentLoaded/
3670							top.doScroll( "left" );
3671						} catch ( e ) {
3672							return window.setTimeout( doScrollCheck, 50 );
3673						}
3674
3675						// detach all dom ready events
3676						detach();
3677
3678						// and execute any waiting functions
3679						jQuery.ready();
3680					}
3681				} )();
3682			}
3683		}
3684	}
3685	return readyList.promise( obj );
3686};
3687
3688// Kick off the DOM ready check even if the user does not
3689jQuery.ready.promise();
3690
3691
3692
3693
3694// Support: IE<9
3695// Iteration over object's inherited properties before its own
3696var i;
3697for ( i in jQuery( support ) ) {
3698	break;
3699}
3700support.ownFirst = i === "0";
3701
3702// Note: most support tests are defined in their respective modules.
3703// false until the test is run
3704support.inlineBlockNeedsLayout = false;
3705
3706// Execute ASAP in case we need to set body.style.zoom
3707jQuery( function() {
3708
3709	// Minified: var a,b,c,d
3710	var val, div, body, container;
3711
3712	body = document.getElementsByTagName( "body" )[ 0 ];
3713	if ( !body || !body.style ) {
3714
3715		// Return for frameset docs that don't have a body
3716		return;
3717	}
3718
3719	// Setup
3720	div = document.createElement( "div" );
3721	container = document.createElement( "div" );
3722	container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px";
3723	body.appendChild( container ).appendChild( div );
3724
3725	if ( typeof div.style.zoom !== "undefined" ) {
3726
3727		// Support: IE<8
3728		// Check if natively block-level elements act like inline-block
3729		// elements when setting their display to 'inline' and giving
3730		// them layout
3731		div.style.cssText = "display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1";
3732
3733		support.inlineBlockNeedsLayout = val = div.offsetWidth === 3;
3734		if ( val ) {
3735
3736			// Prevent IE 6 from affecting layout for positioned elements #11048
3737			// Prevent IE from shrinking the body in IE 7 mode #12869
3738			// Support: IE<8
3739			body.style.zoom = 1;
3740		}
3741	}
3742
3743	body.removeChild( container );
3744} );
3745
3746
3747( function() {
3748	var div = document.createElement( "div" );
3749
3750	// Support: IE<9
3751	support.deleteExpando = true;
3752	try {
3753		delete div.test;
3754	} catch ( e ) {
3755		support.deleteExpando = false;
3756	}
3757
3758	// Null elements to avoid leaks in IE.
3759	div = null;
3760} )();
3761var acceptData = function( elem ) {
3762	var noData = jQuery.noData[ ( elem.nodeName + " " ).toLowerCase() ],
3763		nodeType = +elem.nodeType || 1;
3764
3765	// Do not set data on non-element DOM nodes because it will not be cleared (#8335).
3766	return nodeType !== 1 && nodeType !== 9 ?
3767		false :
3768
3769		// Nodes accept data unless otherwise specified; rejection can be conditional
3770		!noData || noData !== true && elem.getAttribute( "classid" ) === noData;
3771};
3772
3773
3774
3775
3776var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
3777	rmultiDash = /([A-Z])/g;
3778
3779function dataAttr( elem, key, data ) {
3780
3781	// If nothing was found internally, try to fetch any
3782	// data from the HTML5 data-* attribute
3783	if ( data === undefined && elem.nodeType === 1 ) {
3784
3785		var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
3786
3787		data = elem.getAttribute( name );
3788
3789		if ( typeof data === "string" ) {
3790			try {
3791				data = data === "true" ? true :
3792					data === "false" ? false :
3793					data === "null" ? null :
3794
3795					// Only convert to a number if it doesn't change the string
3796					+data + "" === data ? +data :
3797					rbrace.test( data ) ? jQuery.parseJSON( data ) :
3798					data;
3799			} catch ( e ) {}
3800
3801			// Make sure we set the data so it isn't changed later
3802			jQuery.data( elem, key, data );
3803
3804		} else {
3805			data = undefined;
3806		}
3807	}
3808
3809	return data;
3810}
3811
3812// checks a cache object for emptiness
3813function isEmptyDataObject( obj ) {
3814	var name;
3815	for ( name in obj ) {
3816
3817		// if the public data object is empty, the private is still empty
3818		if ( name === "data" && jQuery.isEmptyObject( obj[ name ] ) ) {
3819			continue;
3820		}
3821		if ( name !== "toJSON" ) {
3822			return false;
3823		}
3824	}
3825
3826	return true;
3827}
3828
3829function internalData( elem, name, data, pvt /* Internal Use Only */ ) {
3830	if ( !acceptData( elem ) ) {
3831		return;
3832	}
3833
3834	var ret, thisCache,
3835		internalKey = jQuery.expando,
3836
3837		// We have to handle DOM nodes and JS objects differently because IE6-7
3838		// can't GC object references properly across the DOM-JS boundary
3839		isNode = elem.nodeType,
3840
3841		// Only DOM nodes need the global jQuery cache; JS object data is
3842		// attached directly to the object so GC can occur automatically
3843		cache = isNode ? jQuery.cache : elem,
3844
3845		// Only defining an ID for JS objects if its cache already exists allows
3846		// the code to shortcut on the same path as a DOM node with no cache
3847		id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
3848
3849	// Avoid doing any more work than we need to when trying to get data on an
3850	// object that has no data at all
3851	if ( ( !id || !cache[ id ] || ( !pvt && !cache[ id ].data ) ) &&
3852		data === undefined && typeof name === "string" ) {
3853		return;
3854	}
3855
3856	if ( !id ) {
3857
3858		// Only DOM nodes need a new unique ID for each element since their data
3859		// ends up in the global cache
3860		if ( isNode ) {
3861			id = elem[ internalKey ] = deletedIds.pop() || jQuery.guid++;
3862		} else {
3863			id = internalKey;
3864		}
3865	}
3866
3867	if ( !cache[ id ] ) {
3868
3869		// Avoid exposing jQuery metadata on plain JS objects when the object
3870		// is serialized using JSON.stringify
3871		cache[ id ] = isNode ? {} : { toJSON: jQuery.noop };
3872	}
3873
3874	// An object can be passed to jQuery.data instead of a key/value pair; this gets
3875	// shallow copied over onto the existing cache
3876	if ( typeof name === "object" || typeof name === "function" ) {
3877		if ( pvt ) {
3878			cache[ id ] = jQuery.extend( cache[ id ], name );
3879		} else {
3880			cache[ id ].data = jQuery.extend( cache[ id ].data, name );
3881		}
3882	}
3883
3884	thisCache = cache[ id ];
3885
3886	// jQuery data() is stored in a separate object inside the object's internal data
3887	// cache in order to avoid key collisions between internal data and user-defined
3888	// data.
3889	if ( !pvt ) {
3890		if ( !thisCache.data ) {
3891			thisCache.data = {};
3892		}
3893
3894		thisCache = thisCache.data;
3895	}
3896
3897	if ( data !== undefined ) {
3898		thisCache[ jQuery.camelCase( name ) ] = data;
3899	}
3900
3901	// Check for both converted-to-camel and non-converted data property names
3902	// If a data property was specified
3903	if ( typeof name === "string" ) {
3904
3905		// First Try to find as-is property data
3906		ret = thisCache[ name ];
3907
3908		// Test for null|undefined property data
3909		if ( ret == null ) {
3910
3911			// Try to find the camelCased property
3912			ret = thisCache[ jQuery.camelCase( name ) ];
3913		}
3914	} else {
3915		ret = thisCache;
3916	}
3917
3918	return ret;
3919}
3920
3921function internalRemoveData( elem, name, pvt ) {
3922	if ( !acceptData( elem ) ) {
3923		return;
3924	}
3925
3926	var thisCache, i,
3927		isNode = elem.nodeType,
3928
3929		// See jQuery.data for more information
3930		cache = isNode ? jQuery.cache : elem,
3931		id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
3932
3933	// If there is already no cache entry for this object, there is no
3934	// purpose in continuing
3935	if ( !cache[ id ] ) {
3936		return;
3937	}
3938
3939	if ( name ) {
3940
3941		thisCache = pvt ? cache[ id ] : cache[ id ].data;
3942
3943		if ( thisCache ) {
3944
3945			// Support array or space separated string names for data keys
3946			if ( !jQuery.isArray( name ) ) {
3947
3948				// try the string as a key before any manipulation
3949				if ( name in thisCache ) {
3950					name = [ name ];
3951				} else {
3952
3953					// split the camel cased version by spaces unless a key with the spaces exists
3954					name = jQuery.camelCase( name );
3955					if ( name in thisCache ) {
3956						name = [ name ];
3957					} else {
3958						name = name.split( " " );
3959					}
3960				}
3961			} else {
3962
3963				// If "name" is an array of keys...
3964				// When data is initially created, via ("key", "val") signature,
3965				// keys will be converted to camelCase.
3966				// Since there is no way to tell _how_ a key was added, remove
3967				// both plain key and camelCase key. #12786
3968				// This will only penalize the array argument path.
3969				name = name.concat( jQuery.map( name, jQuery.camelCase ) );
3970			}
3971
3972			i = name.length;
3973			while ( i-- ) {
3974				delete thisCache[ name[ i ] ];
3975			}
3976
3977			// If there is no data left in the cache, we want to continue
3978			// and let the cache object itself get destroyed
3979			if ( pvt ? !isEmptyDataObject( thisCache ) : !jQuery.isEmptyObject( thisCache ) ) {
3980				return;
3981			}
3982		}
3983	}
3984
3985	// See jQuery.data for more information
3986	if ( !pvt ) {
3987		delete cache[ id ].data;
3988
3989		// Don't destroy the parent cache unless the internal data object
3990		// had been the only thing left in it
3991		if ( !isEmptyDataObject( cache[ id ] ) ) {
3992			return;
3993		}
3994	}
3995
3996	// Destroy the cache
3997	if ( isNode ) {
3998		jQuery.cleanData( [ elem ], true );
3999
4000	// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
4001	/* jshint eqeqeq: false */
4002	} else if ( support.deleteExpando || cache != cache.window ) {
4003		/* jshint eqeqeq: true */
4004		delete cache[ id ];
4005
4006	// When all else fails, undefined
4007	} else {
4008		cache[ id ] = undefined;
4009	}
4010}
4011
4012jQuery.extend( {
4013	cache: {},
4014
4015	// The following elements (space-suffixed to avoid Object.prototype collisions)
4016	// throw uncatchable exceptions if you attempt to set expando properties
4017	noData: {
4018		"applet ": true,
4019		"embed ": true,
4020
4021		// ...but Flash objects (which have this classid) *can* handle expandos
4022		"object ": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
4023	},
4024
4025	hasData: function( elem ) {
4026		elem = elem.nodeType ? jQuery.cache[ elem[ jQuery.expando ] ] : elem[ jQuery.expando ];
4027		return !!elem && !isEmptyDataObject( elem );
4028	},
4029
4030	data: function( elem, name, data ) {
4031		return internalData( elem, name, data );
4032	},
4033
4034	removeData: function( elem, name ) {
4035		return internalRemoveData( elem, name );
4036	},
4037
4038	// For internal use only.
4039	_data: function( elem, name, data ) {
4040		return internalData( elem, name, data, true );
4041	},
4042
4043	_removeData: function( elem, name ) {
4044		return internalRemoveData( elem, name, true );
4045	}
4046} );
4047
4048jQuery.fn.extend( {
4049	data: function( key, value ) {
4050		var i, name, data,
4051			elem = this[ 0 ],
4052			attrs = elem && elem.attributes;
4053
4054		// Special expections of .data basically thwart jQuery.access,
4055		// so implement the relevant behavior ourselves
4056
4057		// Gets all values
4058		if ( key === undefined ) {
4059			if ( this.length ) {
4060				data = jQuery.data( elem );
4061
4062				if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
4063					i = attrs.length;
4064					while ( i-- ) {
4065
4066						// Support: IE11+
4067						// The attrs elements can be null (#14894)
4068						if ( attrs[ i ] ) {
4069							name = attrs[ i ].name;
4070							if ( name.indexOf( "data-" ) === 0 ) {
4071								name = jQuery.camelCase( name.slice( 5 ) );
4072								dataAttr( elem, name, data[ name ] );
4073							}
4074						}
4075					}
4076					jQuery._data( elem, "parsedAttrs", true );
4077				}
4078			}
4079
4080			return data;
4081		}
4082
4083		// Sets multiple values
4084		if ( typeof key === "object" ) {
4085			return this.each( function() {
4086				jQuery.data( this, key );
4087			} );
4088		}
4089
4090		return arguments.length > 1 ?
4091
4092			// Sets one value
4093			this.each( function() {
4094				jQuery.data( this, key, value );
4095			} ) :
4096
4097			// Gets one value
4098			// Try to fetch any internally stored data first
4099			elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : undefined;
4100	},
4101
4102	removeData: function( key ) {
4103		return this.each( function() {
4104			jQuery.removeData( this, key );
4105		} );
4106	}
4107} );
4108
4109
4110jQuery.extend( {
4111	queue: function( elem, type, data ) {
4112		var queue;
4113
4114		if ( elem ) {
4115			type = ( type || "fx" ) + "queue";
4116			queue = jQuery._data( elem, type );
4117
4118			// Speed up dequeue by getting out quickly if this is just a lookup
4119			if ( data ) {
4120				if ( !queue || jQuery.isArray( data ) ) {
4121					queue = jQuery._data( elem, type, jQuery.makeArray( data ) );
4122				} else {
4123					queue.push( data );
4124				}
4125			}
4126			return queue || [];
4127		}
4128	},
4129
4130	dequeue: function( elem, type ) {
4131		type = type || "fx";
4132
4133		var queue = jQuery.queue( elem, type ),
4134			startLength = queue.length,
4135			fn = queue.shift(),
4136			hooks = jQuery._queueHooks( elem, type ),
4137			next = function() {
4138				jQuery.dequeue( elem, type );
4139			};
4140
4141		// If the fx queue is dequeued, always remove the progress sentinel
4142		if ( fn === "inprogress" ) {
4143			fn = queue.shift();
4144			startLength--;
4145		}
4146
4147		if ( fn ) {
4148
4149			// Add a progress sentinel to prevent the fx queue from being
4150			// automatically dequeued
4151			if ( type === "fx" ) {
4152				queue.unshift( "inprogress" );
4153			}
4154
4155			// clear up the last queue stop function
4156			delete hooks.stop;
4157			fn.call( elem, next, hooks );
4158		}
4159
4160		if ( !startLength && hooks ) {
4161			hooks.empty.fire();
4162		}
4163	},
4164
4165	// not intended for public consumption - generates a queueHooks object,
4166	// or returns the current one
4167	_queueHooks: function( elem, type ) {
4168		var key = type + "queueHooks";
4169		return jQuery._data( elem, key ) || jQuery._data( elem, key, {
4170			empty: jQuery.Callbacks( "once memory" ).add( function() {
4171				jQuery._removeData( elem, type + "queue" );
4172				jQuery._removeData( elem, key );
4173			} )
4174		} );
4175	}
4176} );
4177
4178jQuery.fn.extend( {
4179	queue: function( type, data ) {
4180		var setter = 2;
4181
4182		if ( typeof type !== "string" ) {
4183			data = type;
4184			type = "fx";
4185			setter--;
4186		}
4187
4188		if ( arguments.length < setter ) {
4189			return jQuery.queue( this[ 0 ], type );
4190		}
4191
4192		return data === undefined ?
4193			this :
4194			this.each( function() {
4195				var queue = jQuery.queue( this, type, data );
4196
4197				// ensure a hooks for this queue
4198				jQuery._queueHooks( this, type );
4199
4200				if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
4201					jQuery.dequeue( this, type );
4202				}
4203			} );
4204	},
4205	dequeue: function( type ) {
4206		return this.each( function() {
4207			jQuery.dequeue( this, type );
4208		} );
4209	},
4210	clearQueue: function( type ) {
4211		return this.queue( type || "fx", [] );
4212	},
4213
4214	// Get a promise resolved when queues of a certain type
4215	// are emptied (fx is the type by default)
4216	promise: function( type, obj ) {
4217		var tmp,
4218			count = 1,
4219			defer = jQuery.Deferred(),
4220			elements = this,
4221			i = this.length,
4222			resolve = function() {
4223				if ( !( --count ) ) {
4224					defer.resolveWith( elements, [ elements ] );
4225				}
4226			};
4227
4228		if ( typeof type !== "string" ) {
4229			obj = type;
4230			type = undefined;
4231		}
4232		type = type || "fx";
4233
4234		while ( i-- ) {
4235			tmp = jQuery._data( elements[ i ], type + "queueHooks" );
4236			if ( tmp && tmp.empty ) {
4237				count++;
4238				tmp.empty.add( resolve );
4239			}
4240		}
4241		resolve();
4242		return defer.promise( obj );
4243	}
4244} );
4245
4246
4247( function() {
4248	var shrinkWrapBlocksVal;
4249
4250	support.shrinkWrapBlocks = function() {
4251		if ( shrinkWrapBlocksVal != null ) {
4252			return shrinkWrapBlocksVal;
4253		}
4254
4255		// Will be changed later if needed.
4256		shrinkWrapBlocksVal = false;
4257
4258		// Minified: var b,c,d
4259		var div, body, container;
4260
4261		body = document.getElementsByTagName( "body" )[ 0 ];
4262		if ( !body || !body.style ) {
4263
4264			// Test fired too early or in an unsupported environment, exit.
4265			return;
4266		}
4267
4268		// Setup
4269		div = document.createElement( "div" );
4270		container = document.createElement( "div" );
4271		container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px";
4272		body.appendChild( container ).appendChild( div );
4273
4274		// Support: IE6
4275		// Check if elements with layout shrink-wrap their children
4276		if ( typeof div.style.zoom !== "undefined" ) {
4277
4278			// Reset CSS: box-sizing; display; margin; border
4279			div.style.cssText =
4280
4281				// Support: Firefox<29, Android 2.3
4282				// Vendor-prefix box-sizing
4283				"-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" +
4284				"box-sizing:content-box;display:block;margin:0;border:0;" +
4285				"padding:1px;width:1px;zoom:1";
4286			div.appendChild( document.createElement( "div" ) ).style.width = "5px";
4287			shrinkWrapBlocksVal = div.offsetWidth !== 3;
4288		}
4289
4290		body.removeChild( container );
4291
4292		return shrinkWrapBlocksVal;
4293	};
4294
4295} )();
4296var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
4297
4298var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
4299
4300
4301var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
4302
4303var isHidden = function( elem, el ) {
4304
4305		// isHidden might be called from jQuery#filter function;
4306		// in that case, element will be second argument
4307		elem = el || elem;
4308		return jQuery.css( elem, "display" ) === "none" ||
4309			!jQuery.contains( elem.ownerDocument, elem );
4310	};
4311
4312
4313
4314function adjustCSS( elem, prop, valueParts, tween ) {
4315	var adjusted,
4316		scale = 1,
4317		maxIterations = 20,
4318		currentValue = tween ?
4319			function() { return tween.cur(); } :
4320			function() { return jQuery.css( elem, prop, "" ); },
4321		initial = currentValue(),
4322		unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
4323
4324		// Starting value computation is required for potential unit mismatches
4325		initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
4326			rcssNum.exec( jQuery.css( elem, prop ) );
4327
4328	if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
4329
4330		// Trust units reported by jQuery.css
4331		unit = unit || initialInUnit[ 3 ];
4332
4333		// Make sure we update the tween properties later on
4334		valueParts = valueParts || [];
4335
4336		// Iteratively approximate from a nonzero starting point
4337		initialInUnit = +initial || 1;
4338
4339		do {
4340
4341			// If previous iteration zeroed out, double until we get *something*.
4342			// Use string for doubling so we don't accidentally see scale as unchanged below
4343			scale = scale || ".5";
4344
4345			// Adjust and apply
4346			initialInUnit = initialInUnit / scale;
4347			jQuery.style( elem, prop, initialInUnit + unit );
4348
4349		// Update scale, tolerating zero or NaN from tween.cur()
4350		// Break the loop if scale is unchanged or perfect, or if we've just had enough.
4351		} while (
4352			scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations
4353		);
4354	}
4355
4356	if ( valueParts ) {
4357		initialInUnit = +initialInUnit || +initial || 0;
4358
4359		// Apply relative offset (+=/-=) if specified
4360		adjusted = valueParts[ 1 ] ?
4361			initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
4362			+valueParts[ 2 ];
4363		if ( tween ) {
4364			tween.unit = unit;
4365			tween.start = initialInUnit;
4366			tween.end = adjusted;
4367		}
4368	}
4369	return adjusted;
4370}
4371
4372
4373// Multifunctional method to get and set values of a collection
4374// The value/s can optionally be executed if it's a function
4375var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
4376	var i = 0,
4377		length = elems.length,
4378		bulk = key == null;
4379
4380	// Sets many values
4381	if ( jQuery.type( key ) === "object" ) {
4382		chainable = true;
4383		for ( i in key ) {
4384			access( elems, fn, i, key[ i ], true, emptyGet, raw );
4385		}
4386
4387	// Sets one value
4388	} else if ( value !== undefined ) {
4389		chainable = true;
4390
4391		if ( !jQuery.isFunction( value ) ) {
4392			raw = true;
4393		}
4394
4395		if ( bulk ) {
4396
4397			// Bulk operations run against the entire set
4398			if ( raw ) {
4399				fn.call( elems, value );
4400				fn = null;
4401
4402			// ...except when executing function values
4403			} else {
4404				bulk = fn;
4405				fn = function( elem, key, value ) {
4406					return bulk.call( jQuery( elem ), value );
4407				};
4408			}
4409		}
4410
4411		if ( fn ) {
4412			for ( ; i < length; i++ ) {
4413				fn(
4414					elems[ i ],
4415					key,
4416					raw ? value : value.call( elems[ i ], i, fn( elems[ i ], key ) )
4417				);
4418			}
4419		}
4420	}
4421
4422	return chainable ?
4423		elems :
4424
4425		// Gets
4426		bulk ?
4427			fn.call( elems ) :
4428			length ? fn( elems[ 0 ], key ) : emptyGet;
4429};
4430var rcheckableType = ( /^(?:checkbox|radio)$/i );
4431
4432var rtagName = ( /<([\w:-]+)/ );
4433
4434var rscriptType = ( /^$|\/(?:java|ecma)script/i );
4435
4436var rleadingWhitespace = ( /^\s+/ );
4437
4438var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|" +
4439		"details|dialog|figcaption|figure|footer|header|hgroup|main|" +
4440		"mark|meter|nav|output|picture|progress|section|summary|template|time|video";
4441
4442
4443
4444function createSafeFragment( document ) {
4445	var list = nodeNames.split( "|" ),
4446		safeFrag = document.createDocumentFragment();
4447
4448	if ( safeFrag.createElement ) {
4449		while ( list.length ) {
4450			safeFrag.createElement(
4451				list.pop()
4452			);
4453		}
4454	}
4455	return safeFrag;
4456}
4457
4458
4459( function() {
4460	var div = document.createElement( "div" ),
4461		fragment = document.createDocumentFragment(),
4462		input = document.createElement( "input" );
4463
4464	// Setup
4465	div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
4466
4467	// IE strips leading whitespace when .innerHTML is used
4468	support.leadingWhitespace = div.firstChild.nodeType === 3;
4469
4470	// Make sure that tbody elements aren't automatically inserted
4471	// IE will insert them into empty tables
4472	support.tbody = !div.getElementsByTagName( "tbody" ).length;
4473
4474	// Make sure that link elements get serialized correctly by innerHTML
4475	// This requires a wrapper element in IE
4476	support.htmlSerialize = !!div.getElementsByTagName( "link" ).length;
4477
4478	// Makes sure cloning an html5 element does not cause problems
4479	// Where outerHTML is undefined, this still works
4480	support.html5Clone =
4481		document.createElement( "nav" ).cloneNode( true ).outerHTML !== "<:nav></:nav>";
4482
4483	// Check if a disconnected checkbox will retain its checked
4484	// value of true after appended to the DOM (IE6/7)
4485	input.type = "checkbox";
4486	input.checked = true;
4487	fragment.appendChild( input );
4488	support.appendChecked = input.checked;
4489
4490	// Make sure textarea (and checkbox) defaultValue is properly cloned
4491	// Support: IE6-IE11+
4492	div.innerHTML = "<textarea>x</textarea>";
4493	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
4494
4495	// #11217 - WebKit loses check when the name is after the checked attribute
4496	fragment.appendChild( div );
4497
4498	// Support: Windows Web Apps (WWA)
4499	// `name` and `type` must use .setAttribute for WWA (#14901)
4500	input = document.createElement( "input" );
4501	input.setAttribute( "type", "radio" );
4502	input.setAttribute( "checked", "checked" );
4503	input.setAttribute( "name", "t" );
4504
4505	div.appendChild( input );
4506
4507	// Support: Safari 5.1, iOS 5.1, Android 4.x, Android 2.3
4508	// old WebKit doesn't clone checked state correctly in fragments
4509	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
4510
4511	// Support: IE<9
4512	// Cloned elements keep attachEvent handlers, we use addEventListener on IE9+
4513	support.noCloneEvent = !!div.addEventListener;
4514
4515	// Support: IE<9
4516	// Since attributes and properties are the same in IE,
4517	// cleanData must set properties to undefined rather than use removeAttribute
4518	div[ jQuery.expando ] = 1;
4519	support.attributes = !div.getAttribute( jQuery.expando );
4520} )();
4521
4522
4523// We have to close these tags to support XHTML (#13200)
4524var wrapMap = {
4525	option: [ 1, "<select multiple='multiple'>", "</select>" ],
4526	legend: [ 1, "<fieldset>", "</fieldset>" ],
4527	area: [ 1, "<map>", "</map>" ],
4528
4529	// Support: IE8
4530	param: [ 1, "<object>", "</object>" ],
4531	thead: [ 1, "<table>", "</table>" ],
4532	tr: [ 2, "<table><tbody>", "</tbody></table>" ],
4533	col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
4534	td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
4535
4536	// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
4537	// unless wrapped in a div with non-breaking characters in front of it.
4538	_default: support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>" ]
4539};
4540
4541// Support: IE8-IE9
4542wrapMap.optgroup = wrapMap.option;
4543
4544wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
4545wrapMap.th = wrapMap.td;
4546
4547
4548function getAll( context, tag ) {
4549	var elems, elem,
4550		i = 0,
4551		found = typeof context.getElementsByTagName !== "undefined" ?
4552			context.getElementsByTagName( tag || "*" ) :
4553			typeof context.querySelectorAll !== "undefined" ?
4554				context.querySelectorAll( tag || "*" ) :
4555				undefined;
4556
4557	if ( !found ) {
4558		for ( found = [], elems = context.childNodes || context;
4559			( elem = elems[ i ] ) != null;
4560			i++
4561		) {
4562			if ( !tag || jQuery.nodeName( elem, tag ) ) {
4563				found.push( elem );
4564			} else {
4565				jQuery.merge( found, getAll( elem, tag ) );
4566			}
4567		}
4568	}
4569
4570	return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
4571		jQuery.merge( [ context ], found ) :
4572		found;
4573}
4574
4575
4576// Mark scripts as having already been evaluated
4577function setGlobalEval( elems, refElements ) {
4578	var elem,
4579		i = 0;
4580	for ( ; ( elem = elems[ i ] ) != null; i++ ) {
4581		jQuery._data(
4582			elem,
4583			"globalEval",
4584			!refElements || jQuery._data( refElements[ i ], "globalEval" )
4585		);
4586	}
4587}
4588
4589
4590var rhtml = /<|&#?\w+;/,
4591	rtbody = /<tbody/i;
4592
4593function fixDefaultChecked( elem ) {
4594	if ( rcheckableType.test( elem.type ) ) {
4595		elem.defaultChecked = elem.checked;
4596	}
4597}
4598
4599function buildFragment( elems, context, scripts, selection, ignored ) {
4600	var j, elem, contains,
4601		tmp, tag, tbody, wrap,
4602		l = elems.length,
4603
4604		// Ensure a safe fragment
4605		safe = createSafeFragment( context ),
4606
4607		nodes = [],
4608		i = 0;
4609
4610	for ( ; i < l; i++ ) {
4611		elem = elems[ i ];
4612
4613		if ( elem || elem === 0 ) {
4614
4615			// Add nodes directly
4616			if ( jQuery.type( elem ) === "object" ) {
4617				jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
4618
4619			// Convert non-html into a text node
4620			} else if ( !rhtml.test( elem ) ) {
4621				nodes.push( context.createTextNode( elem ) );
4622
4623			// Convert html into DOM nodes
4624			} else {
4625				tmp = tmp || safe.appendChild( context.createElement( "div" ) );
4626
4627				// Deserialize a standard representation
4628				tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
4629				wrap = wrapMap[ tag ] || wrapMap._default;
4630
4631				tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
4632
4633				// Descend through wrappers to the right content
4634				j = wrap[ 0 ];
4635				while ( j-- ) {
4636					tmp = tmp.lastChild;
4637				}
4638
4639				// Manually add leading whitespace removed by IE
4640				if ( !support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
4641					nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[ 0 ] ) );
4642				}
4643
4644				// Remove IE's autoinserted <tbody> from table fragments
4645				if ( !support.tbody ) {
4646
4647					// String was a <table>, *may* have spurious <tbody>
4648					elem = tag === "table" && !rtbody.test( elem ) ?
4649						tmp.firstChild :
4650
4651						// String was a bare <thead> or <tfoot>
4652						wrap[ 1 ] === "<table>" && !rtbody.test( elem ) ?
4653							tmp :
4654							0;
4655
4656					j = elem && elem.childNodes.length;
4657					while ( j-- ) {
4658						if ( jQuery.nodeName( ( tbody = elem.childNodes[ j ] ), "tbody" ) &&
4659							!tbody.childNodes.length ) {
4660
4661							elem.removeChild( tbody );
4662						}
4663					}
4664				}
4665
4666				jQuery.merge( nodes, tmp.childNodes );
4667
4668				// Fix #12392 for WebKit and IE > 9
4669				tmp.textContent = "";
4670
4671				// Fix #12392 for oldIE
4672				while ( tmp.firstChild ) {
4673					tmp.removeChild( tmp.firstChild );
4674				}
4675
4676				// Remember the top-level container for proper cleanup
4677				tmp = safe.lastChild;
4678			}
4679		}
4680	}
4681
4682	// Fix #11356: Clear elements from fragment
4683	if ( tmp ) {
4684		safe.removeChild( tmp );
4685	}
4686
4687	// Reset defaultChecked for any radios and checkboxes
4688	// about to be appended to the DOM in IE 6/7 (#8060)
4689	if ( !support.appendChecked ) {
4690		jQuery.grep( getAll( nodes, "input" ), fixDefaultChecked );
4691	}
4692
4693	i = 0;
4694	while ( ( elem = nodes[ i++ ] ) ) {
4695
4696		// Skip elements already in the context collection (trac-4087)
4697		if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
4698			if ( ignored ) {
4699				ignored.push( elem );
4700			}
4701
4702			continue;
4703		}
4704
4705		contains = jQuery.contains( elem.ownerDocument, elem );
4706
4707		// Append to fragment
4708		tmp = getAll( safe.appendChild( elem ), "script" );
4709
4710		// Preserve script evaluation history
4711		if ( contains ) {
4712			setGlobalEval( tmp );
4713		}
4714
4715		// Capture executables
4716		if ( scripts ) {
4717			j = 0;
4718			while ( ( elem = tmp[ j++ ] ) ) {
4719				if ( rscriptType.test( elem.type || "" ) ) {
4720					scripts.push( elem );
4721				}
4722			}
4723		}
4724	}
4725
4726	tmp = null;
4727
4728	return safe;
4729}
4730
4731
4732( function() {
4733	var i, eventName,
4734		div = document.createElement( "div" );
4735
4736	// Support: IE<9 (lack submit/change bubble), Firefox (lack focus(in | out) events)
4737	for ( i in { submit: true, change: true, focusin: true } ) {
4738		eventName = "on" + i;
4739
4740		if ( !( support[ i ] = eventName in window ) ) {
4741
4742			// Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP)
4743			div.setAttribute( eventName, "t" );
4744			support[ i ] = div.attributes[ eventName ].expando === false;
4745		}
4746	}
4747
4748	// Null elements to avoid leaks in IE.
4749	div = null;
4750} )();
4751
4752
4753var rformElems = /^(?:input|select|textarea)$/i,
4754	rkeyEvent = /^key/,
4755	rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
4756	rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
4757	rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
4758
4759function returnTrue() {
4760	return true;
4761}
4762
4763function returnFalse() {
4764	return false;
4765}
4766
4767// Support: IE9
4768// See #13393 for more info
4769function safeActiveElement() {
4770	try {
4771		return document.activeElement;
4772	} catch ( err ) { }
4773}
4774
4775function on( elem, types, selector, data, fn, one ) {
4776	var origFn, type;
4777
4778	// Types can be a map of types/handlers
4779	if ( typeof types === "object" ) {
4780
4781		// ( types-Object, selector, data )
4782		if ( typeof selector !== "string" ) {
4783
4784			// ( types-Object, data )
4785			data = data || selector;
4786			selector = undefined;
4787		}
4788		for ( type in types ) {
4789			on( elem, type, selector, data, types[ type ], one );
4790		}
4791		return elem;
4792	}
4793
4794	if ( data == null && fn == null ) {
4795
4796		// ( types, fn )
4797		fn = selector;
4798		data = selector = undefined;
4799	} else if ( fn == null ) {
4800		if ( typeof selector === "string" ) {
4801
4802			// ( types, selector, fn )
4803			fn = data;
4804			data = undefined;
4805		} else {
4806
4807			// ( types, data, fn )
4808			fn = data;
4809			data = selector;
4810			selector = undefined;
4811		}
4812	}
4813	if ( fn === false ) {
4814		fn = returnFalse;
4815	} else if ( !fn ) {
4816		return elem;
4817	}
4818
4819	if ( one === 1 ) {
4820		origFn = fn;
4821		fn = function( event ) {
4822
4823			// Can use an empty set, since event contains the info
4824			jQuery().off( event );
4825			return origFn.apply( this, arguments );
4826		};
4827
4828		// Use same guid so caller can remove using origFn
4829		fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
4830	}
4831	return elem.each( function() {
4832		jQuery.event.add( this, types, fn, data, selector );
4833	} );
4834}
4835
4836/*
4837 * Helper functions for managing events -- not part of the public interface.
4838 * Props to Dean Edwards' addEvent library for many of the ideas.
4839 */
4840jQuery.event = {
4841
4842	global: {},
4843
4844	add: function( elem, types, handler, data, selector ) {
4845		var tmp, events, t, handleObjIn,
4846			special, eventHandle, handleObj,
4847			handlers, type, namespaces, origType,
4848			elemData = jQuery._data( elem );
4849
4850		// Don't attach events to noData or text/comment nodes (but allow plain objects)
4851		if ( !elemData ) {
4852			return;
4853		}
4854
4855		// Caller can pass in an object of custom data in lieu of the handler
4856		if ( handler.handler ) {
4857			handleObjIn = handler;
4858			handler = handleObjIn.handler;
4859			selector = handleObjIn.selector;
4860		}
4861
4862		// Make sure that the handler has a unique ID, used to find/remove it later
4863		if ( !handler.guid ) {
4864			handler.guid = jQuery.guid++;
4865		}
4866
4867		// Init the element's event structure and main handler, if this is the first
4868		if ( !( events = elemData.events ) ) {
4869			events = elemData.events = {};
4870		}
4871		if ( !( eventHandle = elemData.handle ) ) {
4872			eventHandle = elemData.handle = function( e ) {
4873
4874				// Discard the second event of a jQuery.event.trigger() and
4875				// when an event is called after a page has unloaded
4876				return typeof jQuery !== "undefined" &&
4877					( !e || jQuery.event.triggered !== e.type ) ?
4878					jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
4879					undefined;
4880			};
4881
4882			// Add elem as a property of the handle fn to prevent a memory leak
4883			// with IE non-native events
4884			eventHandle.elem = elem;
4885		}
4886
4887		// Handle multiple events separated by a space
4888		types = ( types || "" ).match( rnotwhite ) || [ "" ];
4889		t = types.length;
4890		while ( t-- ) {
4891			tmp = rtypenamespace.exec( types[ t ] ) || [];
4892			type = origType = tmp[ 1 ];
4893			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
4894
4895			// There *must* be a type, no attaching namespace-only handlers
4896			if ( !type ) {
4897				continue;
4898			}
4899
4900			// If event changes its type, use the special event handlers for the changed type
4901			special = jQuery.event.special[ type ] || {};
4902
4903			// If selector defined, determine special event api type, otherwise given type
4904			type = ( selector ? special.delegateType : special.bindType ) || type;
4905
4906			// Update special based on newly reset type
4907			special = jQuery.event.special[ type ] || {};
4908
4909			// handleObj is passed to all event handlers
4910			handleObj = jQuery.extend( {
4911				type: type,
4912				origType: origType,
4913				data: data,
4914				handler: handler,
4915				guid: handler.guid,
4916				selector: selector,
4917				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
4918				namespace: namespaces.join( "." )
4919			}, handleObjIn );
4920
4921			// Init the event handler queue if we're the first
4922			if ( !( handlers = events[ type ] ) ) {
4923				handlers = events[ type ] = [];
4924				handlers.delegateCount = 0;
4925
4926				// Only use addEventListener/attachEvent if the special events handler returns false
4927				if ( !special.setup ||
4928					special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
4929
4930					// Bind the global event handler to the element
4931					if ( elem.addEventListener ) {
4932						elem.addEventListener( type, eventHandle, false );
4933
4934					} else if ( elem.attachEvent ) {
4935						elem.attachEvent( "on" + type, eventHandle );
4936					}
4937				}
4938			}
4939
4940			if ( special.add ) {
4941				special.add.call( elem, handleObj );
4942
4943				if ( !handleObj.handler.guid ) {
4944					handleObj.handler.guid = handler.guid;
4945				}
4946			}
4947
4948			// Add to the element's handler list, delegates in front
4949			if ( selector ) {
4950				handlers.splice( handlers.delegateCount++, 0, handleObj );
4951			} else {
4952				handlers.push( handleObj );
4953			}
4954
4955			// Keep track of which events have ever been used, for event optimization
4956			jQuery.event.global[ type ] = true;
4957		}
4958
4959		// Nullify elem to prevent memory leaks in IE
4960		elem = null;
4961	},
4962
4963	// Detach an event or set of events from an element
4964	remove: function( elem, types, handler, selector, mappedTypes ) {
4965		var j, handleObj, tmp,
4966			origCount, t, events,
4967			special, handlers, type,
4968			namespaces, origType,
4969			elemData = jQuery.hasData( elem ) && jQuery._data( elem );
4970
4971		if ( !elemData || !( events = elemData.events ) ) {
4972			return;
4973		}
4974
4975		// Once for each type.namespace in types; type may be omitted
4976		types = ( types || "" ).match( rnotwhite ) || [ "" ];
4977		t = types.length;
4978		while ( t-- ) {
4979			tmp = rtypenamespace.exec( types[ t ] ) || [];
4980			type = origType = tmp[ 1 ];
4981			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
4982
4983			// Unbind all events (on this namespace, if provided) for the element
4984			if ( !type ) {
4985				for ( type in events ) {
4986					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
4987				}
4988				continue;
4989			}
4990
4991			special = jQuery.event.special[ type ] || {};
4992			type = ( selector ? special.delegateType : special.bindType ) || type;
4993			handlers = events[ type ] || [];
4994			tmp = tmp[ 2 ] &&
4995				new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
4996
4997			// Remove matching events
4998			origCount = j = handlers.length;
4999			while ( j-- ) {
5000				handleObj = handlers[ j ];
5001
5002				if ( ( mappedTypes || origType === handleObj.origType ) &&
5003					( !handler || handler.guid === handleObj.guid ) &&
5004					( !tmp || tmp.test( handleObj.namespace ) ) &&
5005					( !selector || selector === handleObj.selector ||
5006						selector === "**" && handleObj.selector ) ) {
5007					handlers.splice( j, 1 );
5008
5009					if ( handleObj.selector ) {
5010						handlers.delegateCount--;
5011					}
5012					if ( special.remove ) {
5013						special.remove.call( elem, handleObj );
5014					}
5015				}
5016			}
5017
5018			// Remove generic event handler if we removed something and no more handlers exist
5019			// (avoids potential for endless recursion during removal of special event handlers)
5020			if ( origCount && !handlers.length ) {
5021				if ( !special.teardown ||
5022					special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
5023
5024					jQuery.removeEvent( elem, type, elemData.handle );
5025				}
5026
5027				delete events[ type ];
5028			}
5029		}
5030
5031		// Remove the expando if it's no longer used
5032		if ( jQuery.isEmptyObject( events ) ) {
5033			delete elemData.handle;
5034
5035			// removeData also checks for emptiness and clears the expando if empty
5036			// so use it instead of delete
5037			jQuery._removeData( elem, "events" );
5038		}
5039	},
5040
5041	trigger: function( event, data, elem, onlyHandlers ) {
5042		var handle, ontype, cur,
5043			bubbleType, special, tmp, i,
5044			eventPath = [ elem || document ],
5045			type = hasOwn.call( event, "type" ) ? event.type : event,
5046			namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
5047
5048		cur = tmp = elem = elem || document;
5049
5050		// Don't do events on text and comment nodes
5051		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
5052			return;
5053		}
5054
5055		// focus/blur morphs to focusin/out; ensure we're not firing them right now
5056		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
5057			return;
5058		}
5059
5060		if ( type.indexOf( "." ) > -1 ) {
5061
5062			// Namespaced trigger; create a regexp to match event type in handle()
5063			namespaces = type.split( "." );
5064			type = namespaces.shift();
5065			namespaces.sort();
5066		}
5067		ontype = type.indexOf( ":" ) < 0 && "on" + type;
5068
5069		// Caller can pass in a jQuery.Event object, Object, or just an event type string
5070		event = event[ jQuery.expando ] ?
5071			event :
5072			new jQuery.Event( type, typeof event === "object" && event );
5073
5074		// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
5075		event.isTrigger = onlyHandlers ? 2 : 3;
5076		event.namespace = namespaces.join( "." );
5077		event.rnamespace = event.namespace ?
5078			new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
5079			null;
5080
5081		// Clean up the event in case it is being reused
5082		event.result = undefined;
5083		if ( !event.target ) {
5084			event.target = elem;
5085		}
5086
5087		// Clone any incoming data and prepend the event, creating the handler arg list
5088		data = data == null ?
5089			[ event ] :
5090			jQuery.makeArray( data, [ event ] );
5091
5092		// Allow special events to draw outside the lines
5093		special = jQuery.event.special[ type ] || {};
5094		if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
5095			return;
5096		}
5097
5098		// Determine event propagation path in advance, per W3C events spec (#9951)
5099		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
5100		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
5101
5102			bubbleType = special.delegateType || type;
5103			if ( !rfocusMorph.test( bubbleType + type ) ) {
5104				cur = cur.parentNode;
5105			}
5106			for ( ; cur; cur = cur.parentNode ) {
5107				eventPath.push( cur );
5108				tmp = cur;
5109			}
5110
5111			// Only add window if we got to document (e.g., not plain obj or detached DOM)
5112			if ( tmp === ( elem.ownerDocument || document ) ) {
5113				eventPath.push( tmp.defaultView || tmp.parentWindow || window );
5114			}
5115		}
5116
5117		// Fire handlers on the event path
5118		i = 0;
5119		while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
5120
5121			event.type = i > 1 ?
5122				bubbleType :
5123				special.bindType || type;
5124
5125			// jQuery handler
5126			handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] &&
5127				jQuery._data( cur, "handle" );
5128
5129			if ( handle ) {
5130				handle.apply( cur, data );
5131			}
5132
5133			// Native handler
5134			handle = ontype && cur[ ontype ];
5135			if ( handle && handle.apply && acceptData( cur ) ) {
5136				event.result = handle.apply( cur, data );
5137				if ( event.result === false ) {
5138					event.preventDefault();
5139				}
5140			}
5141		}
5142		event.type = type;
5143
5144		// If nobody prevented the default action, do it now
5145		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
5146
5147			if (
5148				( !special._default ||
5149				 special._default.apply( eventPath.pop(), data ) === false
5150				) && acceptData( elem )
5151			) {
5152
5153				// Call a native DOM method on the target with the same name name as the event.
5154				// Can't use an .isFunction() check here because IE6/7 fails that test.
5155				// Don't do default actions on window, that's where global variables be (#6170)
5156				if ( ontype && elem[ type ] && !jQuery.isWindow( elem ) ) {
5157
5158					// Don't re-trigger an onFOO event when we call its FOO() method
5159					tmp = elem[ ontype ];
5160
5161					if ( tmp ) {
5162						elem[ ontype ] = null;
5163					}
5164
5165					// Prevent re-triggering of the same event, since we already bubbled it above
5166					jQuery.event.triggered = type;
5167					try {
5168						elem[ type ]();
5169					} catch ( e ) {
5170
5171						// IE<9 dies on focus/blur to hidden element (#1486,#12518)
5172						// only reproducible on winXP IE8 native, not IE9 in IE8 mode
5173					}
5174					jQuery.event.triggered = undefined;
5175
5176					if ( tmp ) {
5177						elem[ ontype ] = tmp;
5178					}
5179				}
5180			}
5181		}
5182
5183		return event.result;
5184	},
5185
5186	dispatch: function( event ) {
5187
5188		// Make a writable jQuery.Event from the native event object
5189		event = jQuery.event.fix( event );
5190
5191		var i, j, ret, matched, handleObj,
5192			handlerQueue = [],
5193			args = slice.call( arguments ),
5194			handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [],
5195			special = jQuery.event.special[ event.type ] || {};
5196
5197		// Use the fix-ed jQuery.Event rather than the (read-only) native event
5198		args[ 0 ] = event;
5199		event.delegateTarget = this;
5200
5201		// Call the preDispatch hook for the mapped type, and let it bail if desired
5202		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
5203			return;
5204		}
5205
5206		// Determine handlers
5207		handlerQueue = jQuery.event.handlers.call( this, event, handlers );
5208
5209		// Run delegates first; they may want to stop propagation beneath us
5210		i = 0;
5211		while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
5212			event.currentTarget = matched.elem;
5213
5214			j = 0;
5215			while ( ( handleObj = matched.handlers[ j++ ] ) &&
5216				!event.isImmediatePropagationStopped() ) {
5217
5218				// Triggered event must either 1) have no namespace, or 2) have namespace(s)
5219				// a subset or equal to those in the bound event (both can have no namespace).
5220				if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {
5221
5222					event.handleObj = handleObj;
5223					event.data = handleObj.data;
5224
5225					ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
5226						handleObj.handler ).apply( matched.elem, args );
5227
5228					if ( ret !== undefined ) {
5229						if ( ( event.result = ret ) === false ) {
5230							event.preventDefault();
5231							event.stopPropagation();
5232						}
5233					}
5234				}
5235			}
5236		}
5237
5238		// Call the postDispatch hook for the mapped type
5239		if ( special.postDispatch ) {
5240			special.postDispatch.call( this, event );
5241		}
5242
5243		return event.result;
5244	},
5245
5246	handlers: function( event, handlers ) {
5247		var i, matches, sel, handleObj,
5248			handlerQueue = [],
5249			delegateCount = handlers.delegateCount,
5250			cur = event.target;
5251
5252		// Support (at least): Chrome, IE9
5253		// Find delegate handlers
5254		// Black-hole SVG <use> instance trees (#13180)
5255		//
5256		// Support: Firefox<=42+
5257		// Avoid non-left-click in FF but don't block IE radio events (#3861, gh-2343)
5258		if ( delegateCount && cur.nodeType &&
5259			( event.type !== "click" || isNaN( event.button ) || event.button < 1 ) ) {
5260
5261			/* jshint eqeqeq: false */
5262			for ( ; cur != this; cur = cur.parentNode || this ) {
5263				/* jshint eqeqeq: true */
5264
5265				// Don't check non-elements (#13208)
5266				// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
5267				if ( cur.nodeType === 1 && ( cur.disabled !== true || event.type !== "click" ) ) {
5268					matches = [];
5269					for ( i = 0; i < delegateCount; i++ ) {
5270						handleObj = handlers[ i ];
5271
5272						// Don't conflict with Object.prototype properties (#13203)
5273						sel = handleObj.selector + " ";
5274
5275						if ( matches[ sel ] === undefined ) {
5276							matches[ sel ] = handleObj.needsContext ?
5277								jQuery( sel, this ).index( cur ) > -1 :
5278								jQuery.find( sel, this, null, [ cur ] ).length;
5279						}
5280						if ( matches[ sel ] ) {
5281							matches.push( handleObj );
5282						}
5283					}
5284					if ( matches.length ) {
5285						handlerQueue.push( { elem: cur, handlers: matches } );
5286					}
5287				}
5288			}
5289		}
5290
5291		// Add the remaining (directly-bound) handlers
5292		if ( delegateCount < handlers.length ) {
5293			handlerQueue.push( { elem: this, handlers: handlers.slice( delegateCount ) } );
5294		}
5295
5296		return handlerQueue;
5297	},
5298
5299	fix: function( event ) {
5300		if ( event[ jQuery.expando ] ) {
5301			return event;
5302		}
5303
5304		// Create a writable copy of the event object and normalize some properties
5305		var i, prop, copy,
5306			type = event.type,
5307			originalEvent = event,
5308			fixHook = this.fixHooks[ type ];
5309
5310		if ( !fixHook ) {
5311			this.fixHooks[ type ] = fixHook =
5312				rmouseEvent.test( type ) ? this.mouseHooks :
5313				rkeyEvent.test( type ) ? this.keyHooks :
5314				{};
5315		}
5316		copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
5317
5318		event = new jQuery.Event( originalEvent );
5319
5320		i = copy.length;
5321		while ( i-- ) {
5322			prop = copy[ i ];
5323			event[ prop ] = originalEvent[ prop ];
5324		}
5325
5326		// Support: IE<9
5327		// Fix target property (#1925)
5328		if ( !event.target ) {
5329			event.target = originalEvent.srcElement || document;
5330		}
5331
5332		// Support: Safari 6-8+
5333		// Target should not be a text node (#504, #13143)
5334		if ( event.target.nodeType === 3 ) {
5335			event.target = event.target.parentNode;
5336		}
5337
5338		// Support: IE<9
5339		// For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
5340		event.metaKey = !!event.metaKey;
5341
5342		return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
5343	},
5344
5345	// Includes some event props shared by KeyEvent and MouseEvent
5346	props: ( "altKey bubbles cancelable ctrlKey currentTarget detail eventPhase " +
5347		"metaKey relatedTarget shiftKey target timeStamp view which" ).split( " " ),
5348
5349	fixHooks: {},
5350
5351	keyHooks: {
5352		props: "char charCode key keyCode".split( " " ),
5353		filter: function( event, original ) {
5354
5355			// Add which for key events
5356			if ( event.which == null ) {
5357				event.which = original.charCode != null ? original.charCode : original.keyCode;
5358			}
5359
5360			return event;
5361		}
5362	},
5363
5364	mouseHooks: {
5365		props: ( "button buttons clientX clientY fromElement offsetX offsetY " +
5366			"pageX pageY screenX screenY toElement" ).split( " " ),
5367		filter: function( event, original ) {
5368			var body, eventDoc, doc,
5369				button = original.button,
5370				fromElement = original.fromElement;
5371
5372			// Calculate pageX/Y if missing and clientX/Y available
5373			if ( event.pageX == null && original.clientX != null ) {
5374				eventDoc = event.target.ownerDocument || document;
5375				doc = eventDoc.documentElement;
5376				body = eventDoc.body;
5377
5378				event.pageX = original.clientX +
5379					( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) -
5380					( doc && doc.clientLeft || body && body.clientLeft || 0 );
5381				event.pageY = original.clientY +
5382					( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) -
5383					( doc && doc.clientTop  || body && body.clientTop  || 0 );
5384			}
5385
5386			// Add relatedTarget, if necessary
5387			if ( !event.relatedTarget && fromElement ) {
5388				event.relatedTarget = fromElement === event.target ?
5389					original.toElement :
5390					fromElement;
5391			}
5392
5393			// Add which for click: 1 === left; 2 === middle; 3 === right
5394			// Note: button is not normalized, so don't use it
5395			if ( !event.which && button !== undefined ) {
5396				event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
5397			}
5398
5399			return event;
5400		}
5401	},
5402
5403	special: {
5404		load: {
5405
5406			// Prevent triggered image.load events from bubbling to window.load
5407			noBubble: true
5408		},
5409		focus: {
5410
5411			// Fire native event if possible so blur/focus sequence is correct
5412			trigger: function() {
5413				if ( this !== safeActiveElement() && this.focus ) {
5414					try {
5415						this.focus();
5416						return false;
5417					} catch ( e ) {
5418
5419						// Support: IE<9
5420						// If we error on focus to hidden element (#1486, #12518),
5421						// let .trigger() run the handlers
5422					}
5423				}
5424			},
5425			delegateType: "focusin"
5426		},
5427		blur: {
5428			trigger: function() {
5429				if ( this === safeActiveElement() && this.blur ) {
5430					this.blur();
5431					return false;
5432				}
5433			},
5434			delegateType: "focusout"
5435		},
5436		click: {
5437
5438			// For checkbox, fire native event so checked state will be right
5439			trigger: function() {
5440				if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) {
5441					this.click();
5442					return false;
5443				}
5444			},
5445
5446			// For cross-browser consistency, don't fire native .click() on links
5447			_default: function( event ) {
5448				return jQuery.nodeName( event.target, "a" );
5449			}
5450		},
5451
5452		beforeunload: {
5453			postDispatch: function( event ) {
5454
5455				// Support: Firefox 20+
5456				// Firefox doesn't alert if the returnValue field is not set.
5457				if ( event.result !== undefined && event.originalEvent ) {
5458					event.originalEvent.returnValue = event.result;
5459				}
5460			}
5461		}
5462	},
5463
5464	// Piggyback on a donor event to simulate a different one
5465	simulate: function( type, elem, event ) {
5466		var e = jQuery.extend(
5467			new jQuery.Event(),
5468			event,
5469			{
5470				type: type,
5471				isSimulated: true
5472
5473				// Previously, `originalEvent: {}` was set here, so stopPropagation call
5474				// would not be triggered on donor event, since in our own
5475				// jQuery.event.stopPropagation function we had a check for existence of
5476				// originalEvent.stopPropagation method, so, consequently it would be a noop.
5477				//
5478				// Guard for simulated events was moved to jQuery.event.stopPropagation function
5479				// since `originalEvent` should point to the original event for the
5480				// constancy with other events and for more focused logic
5481			}
5482		);
5483
5484		jQuery.event.trigger( e, null, elem );
5485
5486		if ( e.isDefaultPrevented() ) {
5487			event.preventDefault();
5488		}
5489	}
5490};
5491
5492jQuery.removeEvent = document.removeEventListener ?
5493	function( elem, type, handle ) {
5494
5495		// This "if" is needed for plain objects
5496		if ( elem.removeEventListener ) {
5497			elem.removeEventListener( type, handle );
5498		}
5499	} :
5500	function( elem, type, handle ) {
5501		var name = "on" + type;
5502
5503		if ( elem.detachEvent ) {
5504
5505			// #8545, #7054, preventing memory leaks for custom events in IE6-8
5506			// detachEvent needed property on element, by name of that event,
5507			// to properly expose it to GC
5508			if ( typeof elem[ name ] === "undefined" ) {
5509				elem[ name ] = null;
5510			}
5511
5512			elem.detachEvent( name, handle );
5513		}
5514	};
5515
5516jQuery.Event = function( src, props ) {
5517
5518	// Allow instantiation without the 'new' keyword
5519	if ( !( this instanceof jQuery.Event ) ) {
5520		return new jQuery.Event( src, props );
5521	}
5522
5523	// Event object
5524	if ( src && src.type ) {
5525		this.originalEvent = src;
5526		this.type = src.type;
5527
5528		// Events bubbling up the document may have been marked as prevented
5529		// by a handler lower down the tree; reflect the correct value.
5530		this.isDefaultPrevented = src.defaultPrevented ||
5531				src.defaultPrevented === undefined &&
5532
5533				// Support: IE < 9, Android < 4.0
5534				src.returnValue === false ?
5535			returnTrue :
5536			returnFalse;
5537
5538	// Event type
5539	} else {
5540		this.type = src;
5541	}
5542
5543	// Put explicitly provided properties onto the event object
5544	if ( props ) {
5545		jQuery.extend( this, props );
5546	}
5547
5548	// Create a timestamp if incoming event doesn't have one
5549	this.timeStamp = src && src.timeStamp || jQuery.now();
5550
5551	// Mark it as fixed
5552	this[ jQuery.expando ] = true;
5553};
5554
5555// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
5556// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
5557jQuery.Event.prototype = {
5558	constructor: jQuery.Event,
5559	isDefaultPrevented: returnFalse,
5560	isPropagationStopped: returnFalse,
5561	isImmediatePropagationStopped: returnFalse,
5562
5563	preventDefault: function() {
5564		var e = this.originalEvent;
5565
5566		this.isDefaultPrevented = returnTrue;
5567		if ( !e ) {
5568			return;
5569		}
5570
5571		// If preventDefault exists, run it on the original event
5572		if ( e.preventDefault ) {
5573			e.preventDefault();
5574
5575		// Support: IE
5576		// Otherwise set the returnValue property of the original event to false
5577		} else {
5578			e.returnValue = false;
5579		}
5580	},
5581	stopPropagation: function() {
5582		var e = this.originalEvent;
5583
5584		this.isPropagationStopped = returnTrue;
5585
5586		if ( !e || this.isSimulated ) {
5587			return;
5588		}
5589
5590		// If stopPropagation exists, run it on the original event
5591		if ( e.stopPropagation ) {
5592			e.stopPropagation();
5593		}
5594
5595		// Support: IE
5596		// Set the cancelBubble property of the original event to true
5597		e.cancelBubble = true;
5598	},
5599	stopImmediatePropagation: function() {
5600		var e = this.originalEvent;
5601
5602		this.isImmediatePropagationStopped = returnTrue;
5603
5604		if ( e && e.stopImmediatePropagation ) {
5605			e.stopImmediatePropagation();
5606		}
5607
5608		this.stopPropagation();
5609	}
5610};
5611
5612// Create mouseenter/leave events using mouseover/out and event-time checks
5613// so that event delegation works in jQuery.
5614// Do the same for pointerenter/pointerleave and pointerover/pointerout
5615//
5616// Support: Safari 7 only
5617// Safari sends mouseenter too often; see:
5618// https://code.google.com/p/chromium/issues/detail?id=470258
5619// for the description of the bug (it existed in older Chrome versions as well).
5620jQuery.each( {
5621	mouseenter: "mouseover",
5622	mouseleave: "mouseout",
5623	pointerenter: "pointerover",
5624	pointerleave: "pointerout"
5625}, function( orig, fix ) {
5626	jQuery.event.special[ orig ] = {
5627		delegateType: fix,
5628		bindType: fix,
5629
5630		handle: function( event ) {
5631			var ret,
5632				target = this,
5633				related = event.relatedTarget,
5634				handleObj = event.handleObj;
5635
5636			// For mouseenter/leave call the handler if related is outside the target.
5637			// NB: No relatedTarget if the mouse left/entered the browser window
5638			if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
5639				event.type = handleObj.origType;
5640				ret = handleObj.handler.apply( this, arguments );
5641				event.type = fix;
5642			}
5643			return ret;
5644		}
5645	};
5646} );
5647
5648// IE submit delegation
5649if ( !support.submit ) {
5650
5651	jQuery.event.special.submit = {
5652		setup: function() {
5653
5654			// Only need this for delegated form submit events
5655			if ( jQuery.nodeName( this, "form" ) ) {
5656				return false;
5657			}
5658
5659			// Lazy-add a submit handler when a descendant form may potentially be submitted
5660			jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
5661
5662				// Node name check avoids a VML-related crash in IE (#9807)
5663				var elem = e.target,
5664					form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ?
5665
5666						// Support: IE <=8
5667						// We use jQuery.prop instead of elem.form
5668						// to allow fixing the IE8 delegated submit issue (gh-2332)
5669						// by 3rd party polyfills/workarounds.
5670						jQuery.prop( elem, "form" ) :
5671						undefined;
5672
5673				if ( form && !jQuery._data( form, "submit" ) ) {
5674					jQuery.event.add( form, "submit._submit", function( event ) {
5675						event._submitBubble = true;
5676					} );
5677					jQuery._data( form, "submit", true );
5678				}
5679			} );
5680
5681			// return undefined since we don't need an event listener
5682		},
5683
5684		postDispatch: function( event ) {
5685
5686			// If form was submitted by the user, bubble the event up the tree
5687			if ( event._submitBubble ) {
5688				delete event._submitBubble;
5689				if ( this.parentNode && !event.isTrigger ) {
5690					jQuery.event.simulate( "submit", this.parentNode, event );
5691				}
5692			}
5693		},
5694
5695		teardown: function() {
5696
5697			// Only need this for delegated form submit events
5698			if ( jQuery.nodeName( this, "form" ) ) {
5699				return false;
5700			}
5701
5702			// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
5703			jQuery.event.remove( this, "._submit" );
5704		}
5705	};
5706}
5707
5708// IE change delegation and checkbox/radio fix
5709if ( !support.change ) {
5710
5711	jQuery.event.special.change = {
5712
5713		setup: function() {
5714
5715			if ( rformElems.test( this.nodeName ) ) {
5716
5717				// IE doesn't fire change on a check/radio until blur; trigger it on click
5718				// after a propertychange. Eat the blur-change in special.change.handle.
5719				// This still fires onchange a second time for check/radio after blur.
5720				if ( this.type === "checkbox" || this.type === "radio" ) {
5721					jQuery.event.add( this, "propertychange._change", function( event ) {
5722						if ( event.originalEvent.propertyName === "checked" ) {
5723							this._justChanged = true;
5724						}
5725					} );
5726					jQuery.event.add( this, "click._change", function( event ) {
5727						if ( this._justChanged && !event.isTrigger ) {
5728							this._justChanged = false;
5729						}
5730
5731						// Allow triggered, simulated change events (#11500)
5732						jQuery.event.simulate( "change", this, event );
5733					} );
5734				}
5735				return false;
5736			}
5737
5738			// Delegated event; lazy-add a change handler on descendant inputs
5739			jQuery.event.add( this, "beforeactivate._change", function( e ) {
5740				var elem = e.target;
5741
5742				if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "change" ) ) {
5743					jQuery.event.add( elem, "change._change", function( event ) {
5744						if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
5745							jQuery.event.simulate( "change", this.parentNode, event );
5746						}
5747					} );
5748					jQuery._data( elem, "change", true );
5749				}
5750			} );
5751		},
5752
5753		handle: function( event ) {
5754			var elem = event.target;
5755
5756			// Swallow native change events from checkbox/radio, we already triggered them above
5757			if ( this !== elem || event.isSimulated || event.isTrigger ||
5758				( elem.type !== "radio" && elem.type !== "checkbox" ) ) {
5759
5760				return event.handleObj.handler.apply( this, arguments );
5761			}
5762		},
5763
5764		teardown: function() {
5765			jQuery.event.remove( this, "._change" );
5766
5767			return !rformElems.test( this.nodeName );
5768		}
5769	};
5770}
5771
5772// Support: Firefox
5773// Firefox doesn't have focus(in | out) events
5774// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
5775//
5776// Support: Chrome, Safari
5777// focus(in | out) events fire after focus & blur events,
5778// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
5779// Related ticket - https://code.google.com/p/chromium/issues/detail?id=449857
5780if ( !support.focusin ) {
5781	jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
5782
5783		// Attach a single capturing handler on the document while someone wants focusin/focusout
5784		var handler = function( event ) {
5785			jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
5786		};
5787
5788		jQuery.event.special[ fix ] = {
5789			setup: function() {
5790				var doc = this.ownerDocument || this,
5791					attaches = jQuery._data( doc, fix );
5792
5793				if ( !attaches ) {
5794					doc.addEventListener( orig, handler, true );
5795				}
5796				jQuery._data( doc, fix, ( attaches || 0 ) + 1 );
5797			},
5798			teardown: function() {
5799				var doc = this.ownerDocument || this,
5800					attaches = jQuery._data( doc, fix ) - 1;
5801
5802				if ( !attaches ) {
5803					doc.removeEventListener( orig, handler, true );
5804					jQuery._removeData( doc, fix );
5805				} else {
5806					jQuery._data( doc, fix, attaches );
5807				}
5808			}
5809		};
5810	} );
5811}
5812
5813jQuery.fn.extend( {
5814
5815	on: function( types, selector, data, fn ) {
5816		return on( this, types, selector, data, fn );
5817	},
5818	one: function( types, selector, data, fn ) {
5819		return on( this, types, selector, data, fn, 1 );
5820	},
5821	off: function( types, selector, fn ) {
5822		var handleObj, type;
5823		if ( types && types.preventDefault && types.handleObj ) {
5824
5825			// ( event )  dispatched jQuery.Event
5826			handleObj = types.handleObj;
5827			jQuery( types.delegateTarget ).off(
5828				handleObj.namespace ?
5829					handleObj.origType + "." + handleObj.namespace :
5830					handleObj.origType,
5831				handleObj.selector,
5832				handleObj.handler
5833			);
5834			return this;
5835		}
5836		if ( typeof types === "object" ) {
5837
5838			// ( types-object [, selector] )
5839			for ( type in types ) {
5840				this.off( type, selector, types[ type ] );
5841			}
5842			return this;
5843		}
5844		if ( selector === false || typeof selector === "function" ) {
5845
5846			// ( types [, fn] )
5847			fn = selector;
5848			selector = undefined;
5849		}
5850		if ( fn === false ) {
5851			fn = returnFalse;
5852		}
5853		return this.each( function() {
5854			jQuery.event.remove( this, types, fn, selector );
5855		} );
5856	},
5857
5858	trigger: function( type, data ) {
5859		return this.each( function() {
5860			jQuery.event.trigger( type, data, this );
5861		} );
5862	},
5863	triggerHandler: function( type, data ) {
5864		var elem = this[ 0 ];
5865		if ( elem ) {
5866			return jQuery.event.trigger( type, data, elem, true );
5867		}
5868	}
5869} );
5870
5871
5872var rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g,
5873	rnoshimcache = new RegExp( "<(?:" + nodeNames + ")[\\s/>]", "i" ),
5874	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi,
5875
5876	// Support: IE 10-11, Edge 10240+
5877	// In IE/Edge using regex groups here causes severe slowdowns.
5878	// See https://connect.microsoft.com/IE/feedback/details/1736512/
5879	rnoInnerhtml = /<script|<style|<link/i,
5880
5881	// checked="checked" or checked
5882	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5883	rscriptTypeMasked = /^true\/(.*)/,
5884	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,
5885	safeFragment = createSafeFragment( document ),
5886	fragmentDiv = safeFragment.appendChild( document.createElement( "div" ) );
5887
5888// Support: IE<8
5889// Manipulating tables requires a tbody
5890function manipulationTarget( elem, content ) {
5891	return jQuery.nodeName( elem, "table" ) &&
5892		jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ?
5893
5894		elem.getElementsByTagName( "tbody" )[ 0 ] ||
5895			elem.appendChild( elem.ownerDocument.createElement( "tbody" ) ) :
5896		elem;
5897}
5898
5899// Replace/restore the type attribute of script elements for safe DOM manipulation
5900function disableScript( elem ) {
5901	elem.type = ( jQuery.find.attr( elem, "type" ) !== null ) + "/" + elem.type;
5902	return elem;
5903}
5904function restoreScript( elem ) {
5905	var match = rscriptTypeMasked.exec( elem.type );
5906	if ( match ) {
5907		elem.type = match[ 1 ];
5908	} else {
5909		elem.removeAttribute( "type" );
5910	}
5911	return elem;
5912}
5913
5914function cloneCopyEvent( src, dest ) {
5915	if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
5916		return;
5917	}
5918
5919	var type, i, l,
5920		oldData = jQuery._data( src ),
5921		curData = jQuery._data( dest, oldData ),
5922		events = oldData.events;
5923
5924	if ( events ) {
5925		delete curData.handle;
5926		curData.events = {};
5927
5928		for ( type in events ) {
5929			for ( i = 0, l = events[ type ].length; i < l; i++ ) {
5930				jQuery.event.add( dest, type, events[ type ][ i ] );
5931			}
5932		}
5933	}
5934
5935	// make the cloned public data object a copy from the original
5936	if ( curData.data ) {
5937		curData.data = jQuery.extend( {}, curData.data );
5938	}
5939}
5940
5941function fixCloneNodeIssues( src, dest ) {
5942	var nodeName, e, data;
5943
5944	// We do not need to do anything for non-Elements
5945	if ( dest.nodeType !== 1 ) {
5946		return;
5947	}
5948
5949	nodeName = dest.nodeName.toLowerCase();
5950
5951	// IE6-8 copies events bound via attachEvent when using cloneNode.
5952	if ( !support.noCloneEvent && dest[ jQuery.expando ] ) {
5953		data = jQuery._data( dest );
5954
5955		for ( e in data.events ) {
5956			jQuery.removeEvent( dest, e, data.handle );
5957		}
5958
5959		// Event data gets referenced instead of copied if the expando gets copied too
5960		dest.removeAttribute( jQuery.expando );
5961	}
5962
5963	// IE blanks contents when cloning scripts, and tries to evaluate newly-set text
5964	if ( nodeName === "script" && dest.text !== src.text ) {
5965		disableScript( dest ).text = src.text;
5966		restoreScript( dest );
5967
5968	// IE6-10 improperly clones children of object elements using classid.
5969	// IE10 throws NoModificationAllowedError if parent is null, #12132.
5970	} else if ( nodeName === "object" ) {
5971		if ( dest.parentNode ) {
5972			dest.outerHTML = src.outerHTML;
5973		}
5974
5975		// This path appears unavoidable for IE9. When cloning an object
5976		// element in IE9, the outerHTML strategy above is not sufficient.
5977		// If the src has innerHTML and the destination does not,
5978		// copy the src.innerHTML into the dest.innerHTML. #10324
5979		if ( support.html5Clone && ( src.innerHTML && !jQuery.trim( dest.innerHTML ) ) ) {
5980			dest.innerHTML = src.innerHTML;
5981		}
5982
5983	} else if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
5984
5985		// IE6-8 fails to persist the checked state of a cloned checkbox
5986		// or radio button. Worse, IE6-7 fail to give the cloned element
5987		// a checked appearance if the defaultChecked value isn't also set
5988
5989		dest.defaultChecked = dest.checked = src.checked;
5990
5991		// IE6-7 get confused and end up setting the value of a cloned
5992		// checkbox/radio button to an empty string instead of "on"
5993		if ( dest.value !== src.value ) {
5994			dest.value = src.value;
5995		}
5996
5997	// IE6-8 fails to return the selected option to the default selected
5998	// state when cloning options
5999	} else if ( nodeName === "option" ) {
6000		dest.defaultSelected = dest.selected = src.defaultSelected;
6001
6002	// IE6-8 fails to set the defaultValue to the correct value when
6003	// cloning other types of input fields
6004	} else if ( nodeName === "input" || nodeName === "textarea" ) {
6005		dest.defaultValue = src.defaultValue;
6006	}
6007}
6008
6009function domManip( collection, args, callback, ignored ) {
6010
6011	// Flatten any nested arrays
6012	args = concat.apply( [], args );
6013
6014	var first, node, hasScripts,
6015		scripts, doc, fragment,
6016		i = 0,
6017		l = collection.length,
6018		iNoClone = l - 1,
6019		value = args[ 0 ],
6020		isFunction = jQuery.isFunction( value );
6021
6022	// We can't cloneNode fragments that contain checked, in WebKit
6023	if ( isFunction ||
6024			( l > 1 && typeof value === "string" &&
6025				!support.checkClone && rchecked.test( value ) ) ) {
6026		return collection.each( function( index ) {
6027			var self = collection.eq( index );
6028			if ( isFunction ) {
6029				args[ 0 ] = value.call( this, index, self.html() );
6030			}
6031			domManip( self, args, callback, ignored );
6032		} );
6033	}
6034
6035	if ( l ) {
6036		fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
6037		first = fragment.firstChild;
6038
6039		if ( fragment.childNodes.length === 1 ) {
6040			fragment = first;
6041		}
6042
6043		// Require either new content or an interest in ignored elements to invoke the callback
6044		if ( first || ignored ) {
6045			scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
6046			hasScripts = scripts.length;
6047
6048			// Use the original fragment for the last item
6049			// instead of the first because it can end up
6050			// being emptied incorrectly in certain situations (#8070).
6051			for ( ; i < l; i++ ) {
6052				node = fragment;
6053
6054				if ( i !== iNoClone ) {
6055					node = jQuery.clone( node, true, true );
6056
6057					// Keep references to cloned scripts for later restoration
6058					if ( hasScripts ) {
6059
6060						// Support: Android<4.1, PhantomJS<2
6061						// push.apply(_, arraylike) throws on ancient WebKit
6062						jQuery.merge( scripts, getAll( node, "script" ) );
6063					}
6064				}
6065
6066				callback.call( collection[ i ], node, i );
6067			}
6068
6069			if ( hasScripts ) {
6070				doc = scripts[ scripts.length - 1 ].ownerDocument;
6071
6072				// Reenable scripts
6073				jQuery.map( scripts, restoreScript );
6074
6075				// Evaluate executable scripts on first document insertion
6076				for ( i = 0; i < hasScripts; i++ ) {
6077					node = scripts[ i ];
6078					if ( rscriptType.test( node.type || "" ) &&
6079						!jQuery._data( node, "globalEval" ) &&
6080						jQuery.contains( doc, node ) ) {
6081
6082						if ( node.src ) {
6083
6084							// Optional AJAX dependency, but won't run scripts if not present
6085							if ( jQuery._evalUrl ) {
6086								jQuery._evalUrl( node.src );
6087							}
6088						} else {
6089							jQuery.globalEval(
6090								( node.text || node.textContent || node.innerHTML || "" )
6091									.replace( rcleanScript, "" )
6092							);
6093						}
6094					}
6095				}
6096			}
6097
6098			// Fix #11809: Avoid leaking memory
6099			fragment = first = null;
6100		}
6101	}
6102
6103	return collection;
6104}
6105
6106function remove( elem, selector, keepData ) {
6107	var node,
6108		elems = selector ? jQuery.filter( selector, elem ) : elem,
6109		i = 0;
6110
6111	for ( ; ( node = elems[ i ] ) != null; i++ ) {
6112
6113		if ( !keepData && node.nodeType === 1 ) {
6114			jQuery.cleanData( getAll( node ) );
6115		}
6116
6117		if ( node.parentNode ) {
6118			if ( keepData && jQuery.contains( node.ownerDocument, node ) ) {
6119				setGlobalEval( getAll( node, "script" ) );
6120			}
6121			node.parentNode.removeChild( node );
6122		}
6123	}
6124
6125	return elem;
6126}
6127
6128jQuery.extend( {
6129	htmlPrefilter: function( html ) {
6130		return html.replace( rxhtmlTag, "<$1></$2>" );
6131	},
6132
6133	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
6134		var destElements, node, clone, i, srcElements,
6135			inPage = jQuery.contains( elem.ownerDocument, elem );
6136
6137		if ( support.html5Clone || jQuery.isXMLDoc( elem ) ||
6138			!rnoshimcache.test( "<" + elem.nodeName + ">" ) ) {
6139
6140			clone = elem.cloneNode( true );
6141
6142		// IE<=8 does not properly clone detached, unknown element nodes
6143		} else {
6144			fragmentDiv.innerHTML = elem.outerHTML;
6145			fragmentDiv.removeChild( clone = fragmentDiv.firstChild );
6146		}
6147
6148		if ( ( !support.noCloneEvent || !support.noCloneChecked ) &&
6149				( elem.nodeType === 1 || elem.nodeType === 11 ) && !jQuery.isXMLDoc( elem ) ) {
6150
6151			// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
6152			destElements = getAll( clone );
6153			srcElements = getAll( elem );
6154
6155			// Fix all IE cloning issues
6156			for ( i = 0; ( node = srcElements[ i ] ) != null; ++i ) {
6157
6158				// Ensure that the destination node is not null; Fixes #9587
6159				if ( destElements[ i ] ) {
6160					fixCloneNodeIssues( node, destElements[ i ] );
6161				}
6162			}
6163		}
6164
6165		// Copy the events from the original to the clone
6166		if ( dataAndEvents ) {
6167			if ( deepDataAndEvents ) {
6168				srcElements = srcElements || getAll( elem );
6169				destElements = destElements || getAll( clone );
6170
6171				for ( i = 0; ( node = srcElements[ i ] ) != null; i++ ) {
6172					cloneCopyEvent( node, destElements[ i ] );
6173				}
6174			} else {
6175				cloneCopyEvent( elem, clone );
6176			}
6177		}
6178
6179		// Preserve script evaluation history
6180		destElements = getAll( clone, "script" );
6181		if ( destElements.length > 0 ) {
6182			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
6183		}
6184
6185		destElements = srcElements = node = null;
6186
6187		// Return the cloned set
6188		return clone;
6189	},
6190
6191	cleanData: function( elems, /* internal */ forceAcceptData ) {
6192		var elem, type, id, data,
6193			i = 0,
6194			internalKey = jQuery.expando,
6195			cache = jQuery.cache,
6196			attributes = support.attributes,
6197			special = jQuery.event.special;
6198
6199		for ( ; ( elem = elems[ i ] ) != null; i++ ) {
6200			if ( forceAcceptData || acceptData( elem ) ) {
6201
6202				id = elem[ internalKey ];
6203				data = id && cache[ id ];
6204
6205				if ( data ) {
6206					if ( data.events ) {
6207						for ( type in data.events ) {
6208							if ( special[ type ] ) {
6209								jQuery.event.remove( elem, type );
6210
6211							// This is a shortcut to avoid jQuery.event.remove's overhead
6212							} else {
6213								jQuery.removeEvent( elem, type, data.handle );
6214							}
6215						}
6216					}
6217
6218					// Remove cache only if it was not already removed by jQuery.event.remove
6219					if ( cache[ id ] ) {
6220
6221						delete cache[ id ];
6222
6223						// Support: IE<9
6224						// IE does not allow us to delete expando properties from nodes
6225						// IE creates expando attributes along with the property
6226						// IE does not have a removeAttribute function on Document nodes
6227						if ( !attributes && typeof elem.removeAttribute !== "undefined" ) {
6228							elem.removeAttribute( internalKey );
6229
6230						// Webkit & Blink performance suffers when deleting properties
6231						// from DOM nodes, so set to undefined instead
6232						// https://code.google.com/p/chromium/issues/detail?id=378607
6233						} else {
6234							elem[ internalKey ] = undefined;
6235						}
6236
6237						deletedIds.push( id );
6238					}
6239				}
6240			}
6241		}
6242	}
6243} );
6244
6245jQuery.fn.extend( {
6246
6247	// Keep domManip exposed until 3.0 (gh-2225)
6248	domManip: domManip,
6249
6250	detach: function( selector ) {
6251		return remove( this, selector, true );
6252	},
6253
6254	remove: function( selector ) {
6255		return remove( this, selector );
6256	},
6257
6258	text: function( value ) {
6259		return access( this, function( value ) {
6260			return value === undefined ?
6261				jQuery.text( this ) :
6262				this.empty().append(
6263					( this[ 0 ] && this[ 0 ].ownerDocument || document ).createTextNode( value )
6264				);
6265		}, null, value, arguments.length );
6266	},
6267
6268	append: function() {
6269		return domManip( this, arguments, function( elem ) {
6270			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
6271				var target = manipulationTarget( this, elem );
6272				target.appendChild( elem );
6273			}
6274		} );
6275	},
6276
6277	prepend: function() {
6278		return domManip( this, arguments, function( elem ) {
6279			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
6280				var target = manipulationTarget( this, elem );
6281				target.insertBefore( elem, target.firstChild );
6282			}
6283		} );
6284	},
6285
6286	before: function() {
6287		return domManip( this, arguments, function( elem ) {
6288			if ( this.parentNode ) {
6289				this.parentNode.insertBefore( elem, this );
6290			}
6291		} );
6292	},
6293
6294	after: function() {
6295		return domManip( this, arguments, function( elem ) {
6296			if ( this.parentNode ) {
6297				this.parentNode.insertBefore( elem, this.nextSibling );
6298			}
6299		} );
6300	},
6301
6302	empty: function() {
6303		var elem,
6304			i = 0;
6305
6306		for ( ; ( elem = this[ i ] ) != null; i++ ) {
6307
6308			// Remove element nodes and prevent memory leaks
6309			if ( elem.nodeType === 1 ) {
6310				jQuery.cleanData( getAll( elem, false ) );
6311			}
6312
6313			// Remove any remaining nodes
6314			while ( elem.firstChild ) {
6315				elem.removeChild( elem.firstChild );
6316			}
6317
6318			// If this is a select, ensure that it displays empty (#12336)
6319			// Support: IE<9
6320			if ( elem.options && jQuery.nodeName( elem, "select" ) ) {
6321				elem.options.length = 0;
6322			}
6323		}
6324
6325		return this;
6326	},
6327
6328	clone: function( dataAndEvents, deepDataAndEvents ) {
6329		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
6330		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
6331
6332		return this.map( function() {
6333			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
6334		} );
6335	},
6336
6337	html: function( value ) {
6338		return access( this, function( value ) {
6339			var elem = this[ 0 ] || {},
6340				i = 0,
6341				l = this.length;
6342
6343			if ( value === undefined ) {
6344				return elem.nodeType === 1 ?
6345					elem.innerHTML.replace( rinlinejQuery, "" ) :
6346					undefined;
6347			}
6348
6349			// See if we can take a shortcut and just use innerHTML
6350			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
6351				( support.htmlSerialize || !rnoshimcache.test( value )  ) &&
6352				( support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
6353				!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
6354
6355				value = jQuery.htmlPrefilter( value );
6356
6357				try {
6358					for ( ; i < l; i++ ) {
6359
6360						// Remove element nodes and prevent memory leaks
6361						elem = this[ i ] || {};
6362						if ( elem.nodeType === 1 ) {
6363							jQuery.cleanData( getAll( elem, false ) );
6364							elem.innerHTML = value;
6365						}
6366					}
6367
6368					elem = 0;
6369
6370				// If using innerHTML throws an exception, use the fallback method
6371				} catch ( e ) {}
6372			}
6373
6374			if ( elem ) {
6375				this.empty().append( value );
6376			}
6377		}, null, value, arguments.length );
6378	},
6379
6380	replaceWith: function() {
6381		var ignored = [];
6382
6383		// Make the changes, replacing each non-ignored context element with the new content
6384		return domManip( this, arguments, function( elem ) {
6385			var parent = this.parentNode;
6386
6387			if ( jQuery.inArray( this, ignored ) < 0 ) {
6388				jQuery.cleanData( getAll( this ) );
6389				if ( parent ) {
6390					parent.replaceChild( elem, this );
6391				}
6392			}
6393
6394		// Force callback invocation
6395		}, ignored );
6396	}
6397} );
6398
6399jQuery.each( {
6400	appendTo: "append",
6401	prependTo: "prepend",
6402	insertBefore: "before",
6403	insertAfter: "after",
6404	replaceAll: "replaceWith"
6405}, function( name, original ) {
6406	jQuery.fn[ name ] = function( selector ) {
6407		var elems,
6408			i = 0,
6409			ret = [],
6410			insert = jQuery( selector ),
6411			last = insert.length - 1;
6412
6413		for ( ; i <= last; i++ ) {
6414			elems = i === last ? this : this.clone( true );
6415			jQuery( insert[ i ] )[ original ]( elems );
6416
6417			// Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()
6418			push.apply( ret, elems.get() );
6419		}
6420
6421		return this.pushStack( ret );
6422	};
6423} );
6424
6425
6426var iframe,
6427	elemdisplay = {
6428
6429		// Support: Firefox
6430		// We have to pre-define these values for FF (#10227)
6431		HTML: "block",
6432		BODY: "block"
6433	};
6434
6435/**
6436 * Retrieve the actual display of a element
6437 * @param {String} name nodeName of the element
6438 * @param {Object} doc Document object
6439 */
6440
6441// Called only from within defaultDisplay
6442function actualDisplay( name, doc ) {
6443	var elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
6444
6445		display = jQuery.css( elem[ 0 ], "display" );
6446
6447	// We don't have any data stored on the element,
6448	// so use "detach" method as fast way to get rid of the element
6449	elem.detach();
6450
6451	return display;
6452}
6453
6454/**
6455 * Try to determine the default display value of an element
6456 * @param {String} nodeName
6457 */
6458function defaultDisplay( nodeName ) {
6459	var doc = document,
6460		display = elemdisplay[ nodeName ];
6461
6462	if ( !display ) {
6463		display = actualDisplay( nodeName, doc );
6464
6465		// If the simple way fails, read from inside an iframe
6466		if ( display === "none" || !display ) {
6467
6468			// Use the already-created iframe if possible
6469			iframe = ( iframe || jQuery( "<iframe frameborder='0' width='0' height='0'/>" ) )
6470				.appendTo( doc.documentElement );
6471
6472			// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
6473			doc = ( iframe[ 0 ].contentWindow || iframe[ 0 ].contentDocument ).document;
6474
6475			// Support: IE
6476			doc.write();
6477			doc.close();
6478
6479			display = actualDisplay( nodeName, doc );
6480			iframe.detach();
6481		}
6482
6483		// Store the correct default display
6484		elemdisplay[ nodeName ] = display;
6485	}
6486
6487	return display;
6488}
6489var rmargin = ( /^margin/ );
6490
6491var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
6492
6493var swap = function( elem, options, callback, args ) {
6494	var ret, name,
6495		old = {};
6496
6497	// Remember the old values, and insert the new ones
6498	for ( name in options ) {
6499		old[ name ] = elem.style[ name ];
6500		elem.style[ name ] = options[ name ];
6501	}
6502
6503	ret = callback.apply( elem, args || [] );
6504
6505	// Revert the old values
6506	for ( name in options ) {
6507		elem.style[ name ] = old[ name ];
6508	}
6509
6510	return ret;
6511};
6512
6513
6514var documentElement = document.documentElement;
6515
6516
6517
6518( function() {
6519	var pixelPositionVal, pixelMarginRightVal, boxSizingReliableVal,
6520		reliableHiddenOffsetsVal, reliableMarginRightVal, reliableMarginLeftVal,
6521		container = document.createElement( "div" ),
6522		div = document.createElement( "div" );
6523
6524	// Finish early in limited (non-browser) environments
6525	if ( !div.style ) {
6526		return;
6527	}
6528
6529	div.style.cssText = "float:left;opacity:.5";
6530
6531	// Support: IE<9
6532	// Make sure that element opacity exists (as opposed to filter)
6533	support.opacity = div.style.opacity === "0.5";
6534
6535	// Verify style float existence
6536	// (IE uses styleFloat instead of cssFloat)
6537	support.cssFloat = !!div.style.cssFloat;
6538
6539	div.style.backgroundClip = "content-box";
6540	div.cloneNode( true ).style.backgroundClip = "";
6541	support.clearCloneStyle = div.style.backgroundClip === "content-box";
6542
6543	container = document.createElement( "div" );
6544	container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
6545		"padding:0;margin-top:1px;position:absolute";
6546	div.innerHTML = "";
6547	container.appendChild( div );
6548
6549	// Support: Firefox<29, Android 2.3
6550	// Vendor-prefix box-sizing
6551	support.boxSizing = div.style.boxSizing === "" || div.style.MozBoxSizing === "" ||
6552		div.style.WebkitBoxSizing === "";
6553
6554	jQuery.extend( support, {
6555		reliableHiddenOffsets: function() {
6556			if ( pixelPositionVal == null ) {
6557				computeStyleTests();
6558			}
6559			return reliableHiddenOffsetsVal;
6560		},
6561
6562		boxSizingReliable: function() {
6563
6564			// We're checking for pixelPositionVal here instead of boxSizingReliableVal
6565			// since that compresses better and they're computed together anyway.
6566			if ( pixelPositionVal == null ) {
6567				computeStyleTests();
6568			}
6569			return boxSizingReliableVal;
6570		},
6571
6572		pixelMarginRight: function() {
6573
6574			// Support: Android 4.0-4.3
6575			if ( pixelPositionVal == null ) {
6576				computeStyleTests();
6577			}
6578			return pixelMarginRightVal;
6579		},
6580
6581		pixelPosition: function() {
6582			if ( pixelPositionVal == null ) {
6583				computeStyleTests();
6584			}
6585			return pixelPositionVal;
6586		},
6587
6588		reliableMarginRight: function() {
6589
6590			// Support: Android 2.3
6591			if ( pixelPositionVal == null ) {
6592				computeStyleTests();
6593			}
6594			return reliableMarginRightVal;
6595		},
6596
6597		reliableMarginLeft: function() {
6598
6599			// Support: IE <=8 only, Android 4.0 - 4.3 only, Firefox <=3 - 37
6600			if ( pixelPositionVal == null ) {
6601				computeStyleTests();
6602			}
6603			return reliableMarginLeftVal;
6604		}
6605	} );
6606
6607	function computeStyleTests() {
6608		var contents, divStyle,
6609			documentElement = document.documentElement;
6610
6611		// Setup
6612		documentElement.appendChild( container );
6613
6614		div.style.cssText =
6615
6616			// Support: Android 2.3
6617			// Vendor-prefix box-sizing
6618			"-webkit-box-sizing:border-box;box-sizing:border-box;" +
6619			"position:relative;display:block;" +
6620			"margin:auto;border:1px;padding:1px;" +
6621			"top:1%;width:50%";
6622
6623		// Support: IE<9
6624		// Assume reasonable values in the absence of getComputedStyle
6625		pixelPositionVal = boxSizingReliableVal = reliableMarginLeftVal = false;
6626		pixelMarginRightVal = reliableMarginRightVal = true;
6627
6628		// Check for getComputedStyle so that this code is not run in IE<9.
6629		if ( window.getComputedStyle ) {
6630			divStyle = window.getComputedStyle( div );
6631			pixelPositionVal = ( divStyle || {} ).top !== "1%";
6632			reliableMarginLeftVal = ( divStyle || {} ).marginLeft === "2px";
6633			boxSizingReliableVal = ( divStyle || { width: "4px" } ).width === "4px";
6634
6635			// Support: Android 4.0 - 4.3 only
6636			// Some styles come back with percentage values, even though they shouldn't
6637			div.style.marginRight = "50%";
6638			pixelMarginRightVal = ( divStyle || { marginRight: "4px" } ).marginRight === "4px";
6639
6640			// Support: Android 2.3 only
6641			// Div with explicit width and no margin-right incorrectly
6642			// gets computed margin-right based on width of container (#3333)
6643			// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
6644			contents = div.appendChild( document.createElement( "div" ) );
6645
6646			// Reset CSS: box-sizing; display; margin; border; padding
6647			contents.style.cssText = div.style.cssText =
6648
6649				// Support: Android 2.3
6650				// Vendor-prefix box-sizing
6651				"-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" +
6652				"box-sizing:content-box;display:block;margin:0;border:0;padding:0";
6653			contents.style.marginRight = contents.style.width = "0";
6654			div.style.width = "1px";
6655
6656			reliableMarginRightVal =
6657				!parseFloat( ( window.getComputedStyle( contents ) || {} ).marginRight );
6658
6659			div.removeChild( contents );
6660		}
6661
6662		// Support: IE6-8
6663		// First check that getClientRects works as expected
6664		// Check if table cells still have offsetWidth/Height when they are set
6665		// to display:none and there are still other visible table cells in a
6666		// table row; if so, offsetWidth/Height are not reliable for use when
6667		// determining if an element has been hidden directly using
6668		// display:none (it is still safe to use offsets if a parent element is
6669		// hidden; don safety goggles and see bug #4512 for more information).
6670		div.style.display = "none";
6671		reliableHiddenOffsetsVal = div.getClientRects().length === 0;
6672		if ( reliableHiddenOffsetsVal ) {
6673			div.style.display = "";
6674			div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
6675			contents = div.getElementsByTagName( "td" );
6676			contents[ 0 ].style.cssText = "margin:0;border:0;padding:0;display:none";
6677			reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;
6678			if ( reliableHiddenOffsetsVal ) {
6679				contents[ 0 ].style.display = "";
6680				contents[ 1 ].style.display = "none";
6681				reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;
6682			}
6683		}
6684
6685		// Teardown
6686		documentElement.removeChild( container );
6687	}
6688
6689} )();
6690
6691
6692var getStyles, curCSS,
6693	rposition = /^(top|right|bottom|left)$/;
6694
6695if ( window.getComputedStyle ) {
6696	getStyles = function( elem ) {
6697
6698		// Support: IE<=11+, Firefox<=30+ (#15098, #14150)
6699		// IE throws on elements created in popups
6700		// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
6701		var view = elem.ownerDocument.defaultView;
6702
6703		if ( !view || !view.opener ) {
6704			view = window;
6705		}
6706
6707		return view.getComputedStyle( elem );
6708	};
6709
6710	curCSS = function( elem, name, computed ) {
6711		var width, minWidth, maxWidth, ret,
6712			style = elem.style;
6713
6714		computed = computed || getStyles( elem );
6715
6716		// getPropertyValue is only needed for .css('filter') in IE9, see #12537
6717		ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined;
6718
6719		// Support: Opera 12.1x only
6720		// Fall back to style even without computed
6721		// computed is undefined for elems on document fragments
6722		if ( ( ret === "" || ret === undefined ) && !jQuery.contains( elem.ownerDocument, elem ) ) {
6723			ret = jQuery.style( elem, name );
6724		}
6725
6726		if ( computed ) {
6727
6728			// A tribute to the "awesome hack by Dean Edwards"
6729			// Chrome < 17 and Safari 5.0 uses "computed value"
6730			// instead of "used value" for margin-right
6731			// Safari 5.1.7 (at least) returns percentage for a larger set of values,
6732			// but width seems to be reliably pixels
6733			// this is against the CSSOM draft spec:
6734			// http://dev.w3.org/csswg/cssom/#resolved-values
6735			if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {
6736
6737				// Remember the original values
6738				width = style.width;
6739				minWidth = style.minWidth;
6740				maxWidth = style.maxWidth;
6741
6742				// Put in the new values to get a computed value out
6743				style.minWidth = style.maxWidth = style.width = ret;
6744				ret = computed.width;
6745
6746				// Revert the changed values
6747				style.width = width;
6748				style.minWidth = minWidth;
6749				style.maxWidth = maxWidth;
6750			}
6751		}
6752
6753		// Support: IE
6754		// IE returns zIndex value as an integer.
6755		return ret === undefined ?
6756			ret :
6757			ret + "";
6758	};
6759} else if ( documentElement.currentStyle ) {
6760	getStyles = function( elem ) {
6761		return elem.currentStyle;
6762	};
6763
6764	curCSS = function( elem, name, computed ) {
6765		var left, rs, rsLeft, ret,
6766			style = elem.style;
6767
6768		computed = computed || getStyles( elem );
6769		ret = computed ? computed[ name ] : undefined;
6770
6771		// Avoid setting ret to empty string here
6772		// so we don't default to auto
6773		if ( ret == null && style && style[ name ] ) {
6774			ret = style[ name ];
6775		}
6776
6777		// From the awesome hack by Dean Edwards
6778		// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
6779
6780		// If we're not dealing with a regular pixel number
6781		// but a number that has a weird ending, we need to convert it to pixels
6782		// but not position css attributes, as those are
6783		// proportional to the parent element instead
6784		// and we can't measure the parent instead because it
6785		// might trigger a "stacking dolls" problem
6786		if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) {
6787
6788			// Remember the original values
6789			left = style.left;
6790			rs = elem.runtimeStyle;
6791			rsLeft = rs && rs.left;
6792
6793			// Put in the new values to get a computed value out
6794			if ( rsLeft ) {
6795				rs.left = elem.currentStyle.left;
6796			}
6797			style.left = name === "fontSize" ? "1em" : ret;
6798			ret = style.pixelLeft + "px";
6799
6800			// Revert the changed values
6801			style.left = left;
6802			if ( rsLeft ) {
6803				rs.left = rsLeft;
6804			}
6805		}
6806
6807		// Support: IE
6808		// IE returns zIndex value as an integer.
6809		return ret === undefined ?
6810			ret :
6811			ret + "" || "auto";
6812	};
6813}
6814
6815
6816
6817
6818function addGetHookIf( conditionFn, hookFn ) {
6819
6820	// Define the hook, we'll check on the first run if it's really needed.
6821	return {
6822		get: function() {
6823			if ( conditionFn() ) {
6824
6825				// Hook not needed (or it's not possible to use it due
6826				// to missing dependency), remove it.
6827				delete this.get;
6828				return;
6829			}
6830
6831			// Hook needed; redefine it so that the support test is not executed again.
6832			return ( this.get = hookFn ).apply( this, arguments );
6833		}
6834	};
6835}
6836
6837
6838var
6839
6840		ralpha = /alpha\([^)]*\)/i,
6841	ropacity = /opacity\s*=\s*([^)]*)/i,
6842
6843	// swappable if display is none or starts with table except
6844	// "table", "table-cell", or "table-caption"
6845	// see here for display values:
6846	// https://developer.mozilla.org/en-US/docs/CSS/display
6847	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
6848	rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ),
6849
6850	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
6851	cssNormalTransform = {
6852		letterSpacing: "0",
6853		fontWeight: "400"
6854	},
6855
6856	cssPrefixes = [ "Webkit", "O", "Moz", "ms" ],
6857	emptyStyle = document.createElement( "div" ).style;
6858
6859
6860// return a css property mapped to a potentially vendor prefixed property
6861function vendorPropName( name ) {
6862
6863	// shortcut for names that are not vendor prefixed
6864	if ( name in emptyStyle ) {
6865		return name;
6866	}
6867
6868	// check for vendor prefixed names
6869	var capName = name.charAt( 0 ).toUpperCase() + name.slice( 1 ),
6870		i = cssPrefixes.length;
6871
6872	while ( i-- ) {
6873		name = cssPrefixes[ i ] + capName;
6874		if ( name in emptyStyle ) {
6875			return name;
6876		}
6877	}
6878}
6879
6880function showHide( elements, show ) {
6881	var display, elem, hidden,
6882		values = [],
6883		index = 0,
6884		length = elements.length;
6885
6886	for ( ; index < length; index++ ) {
6887		elem = elements[ index ];
6888		if ( !elem.style ) {
6889			continue;
6890		}
6891
6892		values[ index ] = jQuery._data( elem, "olddisplay" );
6893		display = elem.style.display;
6894		if ( show ) {
6895
6896			// Reset the inline display of this element to learn if it is
6897			// being hidden by cascaded rules or not
6898			if ( !values[ index ] && display === "none" ) {
6899				elem.style.display = "";
6900			}
6901
6902			// Set elements which have been overridden with display: none
6903			// in a stylesheet to whatever the default browser style is
6904			// for such an element
6905			if ( elem.style.display === "" && isHidden( elem ) ) {
6906				values[ index ] =
6907					jQuery._data( elem, "olddisplay", defaultDisplay( elem.nodeName ) );
6908			}
6909		} else {
6910			hidden = isHidden( elem );
6911
6912			if ( display && display !== "none" || !hidden ) {
6913				jQuery._data(
6914					elem,
6915					"olddisplay",
6916					hidden ? display : jQuery.css( elem, "display" )
6917				);
6918			}
6919		}
6920	}
6921
6922	// Set the display of most of the elements in a second loop
6923	// to avoid the constant reflow
6924	for ( index = 0; index < length; index++ ) {
6925		elem = elements[ index ];
6926		if ( !elem.style ) {
6927			continue;
6928		}
6929		if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
6930			elem.style.display = show ? values[ index ] || "" : "none";
6931		}
6932	}
6933
6934	return elements;
6935}
6936
6937function setPositiveNumber( elem, value, subtract ) {
6938	var matches = rnumsplit.exec( value );
6939	return matches ?
6940
6941		// Guard against undefined "subtract", e.g., when used as in cssHooks
6942		Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
6943		value;
6944}
6945
6946function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
6947	var i = extra === ( isBorderBox ? "border" : "content" ) ?
6948
6949		// If we already have the right measurement, avoid augmentation
6950		4 :
6951
6952		// Otherwise initialize for horizontal or vertical properties
6953		name === "width" ? 1 : 0,
6954
6955		val = 0;
6956
6957	for ( ; i < 4; i += 2 ) {
6958
6959		// both box models exclude margin, so add it if we want it
6960		if ( extra === "margin" ) {
6961			val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
6962		}
6963
6964		if ( isBorderBox ) {
6965
6966			// border-box includes padding, so remove it if we want content
6967			if ( extra === "content" ) {
6968				val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6969			}
6970
6971			// at this point, extra isn't border nor margin, so remove border
6972			if ( extra !== "margin" ) {
6973				val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6974			}
6975		} else {
6976
6977			// at this point, extra isn't content, so add padding
6978			val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6979
6980			// at this point, extra isn't content nor padding, so add border
6981			if ( extra !== "padding" ) {
6982				val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6983			}
6984		}
6985	}
6986
6987	return val;
6988}
6989
6990function getWidthOrHeight( elem, name, extra ) {
6991
6992	// Start with offset property, which is equivalent to the border-box value
6993	var valueIsBorderBox = true,
6994		val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
6995		styles = getStyles( elem ),
6996		isBorderBox = support.boxSizing &&
6997			jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
6998
6999	// Support: IE11 only
7000	// In IE 11 fullscreen elements inside of an iframe have
7001	// 100x too small dimensions (gh-1764).
7002	if ( document.msFullscreenElement && window.top !== window ) {
7003
7004		// Support: IE11 only
7005		// Running getBoundingClientRect on a disconnected node
7006		// in IE throws an error.
7007		if ( elem.getClientRects().length ) {
7008			val = Math.round( elem.getBoundingClientRect()[ name ] * 100 );
7009		}
7010	}
7011
7012	// some non-html elements return undefined for offsetWidth, so check for null/undefined
7013	// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
7014	// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
7015	if ( val <= 0 || val == null ) {
7016
7017		// Fall back to computed then uncomputed css if necessary
7018		val = curCSS( elem, name, styles );
7019		if ( val < 0 || val == null ) {
7020			val = elem.style[ name ];
7021		}
7022
7023		// Computed unit is not pixels. Stop here and return.
7024		if ( rnumnonpx.test( val ) ) {
7025			return val;
7026		}
7027
7028		// we need the check for style in case a browser which returns unreliable values
7029		// for getComputedStyle silently falls back to the reliable elem.style
7030		valueIsBorderBox = isBorderBox &&
7031			( support.boxSizingReliable() || val === elem.style[ name ] );
7032
7033		// Normalize "", auto, and prepare for extra
7034		val = parseFloat( val ) || 0;
7035	}
7036
7037	// use the active box-sizing model to add/subtract irrelevant styles
7038	return ( val +
7039		augmentWidthOrHeight(
7040			elem,
7041			name,
7042			extra || ( isBorderBox ? "border" : "content" ),
7043			valueIsBorderBox,
7044			styles
7045		)
7046	) + "px";
7047}
7048
7049jQuery.extend( {
7050
7051	// Add in style property hooks for overriding the default
7052	// behavior of getting and setting a style property
7053	cssHooks: {
7054		opacity: {
7055			get: function( elem, computed ) {
7056				if ( computed ) {
7057
7058					// We should always get a number back from opacity
7059					var ret = curCSS( elem, "opacity" );
7060					return ret === "" ? "1" : ret;
7061				}
7062			}
7063		}
7064	},
7065
7066	// Don't automatically add "px" to these possibly-unitless properties
7067	cssNumber: {
7068		"animationIterationCount": true,
7069		"columnCount": true,
7070		"fillOpacity": true,
7071		"flexGrow": true,
7072		"flexShrink": true,
7073		"fontWeight": true,
7074		"lineHeight": true,
7075		"opacity": true,
7076		"order": true,
7077		"orphans": true,
7078		"widows": true,
7079		"zIndex": true,
7080		"zoom": true
7081	},
7082
7083	// Add in properties whose names you wish to fix before
7084	// setting or getting the value
7085	cssProps: {
7086
7087		// normalize float css property
7088		"float": support.cssFloat ? "cssFloat" : "styleFloat"
7089	},
7090
7091	// Get and set the style property on a DOM Node
7092	style: function( elem, name, value, extra ) {
7093
7094		// Don't set styles on text and comment nodes
7095		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
7096			return;
7097		}
7098
7099		// Make sure that we're working with the right name
7100		var ret, type, hooks,
7101			origName = jQuery.camelCase( name ),
7102			style = elem.style;
7103
7104		name = jQuery.cssProps[ origName ] ||
7105			( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );
7106
7107		// gets hook for the prefixed version
7108		// followed by the unprefixed version
7109		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
7110
7111		// Check if we're setting a value
7112		if ( value !== undefined ) {
7113			type = typeof value;
7114
7115			// Convert "+=" or "-=" to relative numbers (#7345)
7116			if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
7117				value = adjustCSS( elem, name, ret );
7118
7119				// Fixes bug #9237
7120				type = "number";
7121			}
7122
7123			// Make sure that null and NaN values aren't set. See: #7116
7124			if ( value == null || value !== value ) {
7125				return;
7126			}
7127
7128			// If a number was passed in, add the unit (except for certain CSS properties)
7129			if ( type === "number" ) {
7130				value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
7131			}
7132
7133			// Fixes #8908, it can be done more correctly by specifing setters in cssHooks,
7134			// but it would mean to define eight
7135			// (for every problematic property) identical functions
7136			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
7137				style[ name ] = "inherit";
7138			}
7139
7140			// If a hook was provided, use that value, otherwise just set the specified value
7141			if ( !hooks || !( "set" in hooks ) ||
7142				( value = hooks.set( elem, value, extra ) ) !== undefined ) {
7143
7144				// Support: IE
7145				// Swallow errors from 'invalid' CSS values (#5509)
7146				try {
7147					style[ name ] = value;
7148				} catch ( e ) {}
7149			}
7150
7151		} else {
7152
7153			// If a hook was provided get the non-computed value from there
7154			if ( hooks && "get" in hooks &&
7155				( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
7156
7157				return ret;
7158			}
7159
7160			// Otherwise just get the value from the style object
7161			return style[ name ];
7162		}
7163	},
7164
7165	css: function( elem, name, extra, styles ) {
7166		var num, val, hooks,
7167			origName = jQuery.camelCase( name );
7168
7169		// Make sure that we're working with the right name
7170		name = jQuery.cssProps[ origName ] ||
7171			( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );
7172
7173		// gets hook for the prefixed version
7174		// followed by the unprefixed version
7175		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
7176
7177		// If a hook was provided get the computed value from there
7178		if ( hooks && "get" in hooks ) {
7179			val = hooks.get( elem, true, extra );
7180		}
7181
7182		// Otherwise, if a way to get the computed value exists, use that
7183		if ( val === undefined ) {
7184			val = curCSS( elem, name, styles );
7185		}
7186
7187		//convert "normal" to computed value
7188		if ( val === "normal" && name in cssNormalTransform ) {
7189			val = cssNormalTransform[ name ];
7190		}
7191
7192		// Return, converting to number if forced or a qualifier was provided and val looks numeric
7193		if ( extra === "" || extra ) {
7194			num = parseFloat( val );
7195			return extra === true || isFinite( num ) ? num || 0 : val;
7196		}
7197		return val;
7198	}
7199} );
7200
7201jQuery.each( [ "height", "width" ], function( i, name ) {
7202	jQuery.cssHooks[ name ] = {
7203		get: function( elem, computed, extra ) {
7204			if ( computed ) {
7205
7206				// certain elements can have dimension info if we invisibly show them
7207				// however, it must have a current display style that would benefit from this
7208				return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
7209					elem.offsetWidth === 0 ?
7210						swap( elem, cssShow, function() {
7211							return getWidthOrHeight( elem, name, extra );
7212						} ) :
7213						getWidthOrHeight( elem, name, extra );
7214			}
7215		},
7216
7217		set: function( elem, value, extra ) {
7218			var styles = extra && getStyles( elem );
7219			return setPositiveNumber( elem, value, extra ?
7220				augmentWidthOrHeight(
7221					elem,
7222					name,
7223					extra,
7224					support.boxSizing &&
7225						jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
7226					styles
7227				) : 0
7228			);
7229		}
7230	};
7231} );
7232
7233if ( !support.opacity ) {
7234	jQuery.cssHooks.opacity = {
7235		get: function( elem, computed ) {
7236
7237			// IE uses filters for opacity
7238			return ropacity.test( ( computed && elem.currentStyle ?
7239				elem.currentStyle.filter :
7240				elem.style.filter ) || "" ) ?
7241					( 0.01 * parseFloat( RegExp.$1 ) ) + "" :
7242					computed ? "1" : "";
7243		},
7244
7245		set: function( elem, value ) {
7246			var style = elem.style,
7247				currentStyle = elem.currentStyle,
7248				opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
7249				filter = currentStyle && currentStyle.filter || style.filter || "";
7250
7251			// IE has trouble with opacity if it does not have layout
7252			// Force it by setting the zoom level
7253			style.zoom = 1;
7254
7255			// if setting opacity to 1, and no other filters exist -
7256			// attempt to remove filter attribute #6652
7257			// if value === "", then remove inline opacity #12685
7258			if ( ( value >= 1 || value === "" ) &&
7259					jQuery.trim( filter.replace( ralpha, "" ) ) === "" &&
7260					style.removeAttribute ) {
7261
7262				// Setting style.filter to null, "" & " " still leave "filter:" in the cssText
7263				// if "filter:" is present at all, clearType is disabled, we want to avoid this
7264				// style.removeAttribute is IE Only, but so apparently is this code path...
7265				style.removeAttribute( "filter" );
7266
7267				// if there is no filter style applied in a css rule
7268				// or unset inline opacity, we are done
7269				if ( value === "" || currentStyle && !currentStyle.filter ) {
7270					return;
7271				}
7272			}
7273
7274			// otherwise, set new filter values
7275			style.filter = ralpha.test( filter ) ?
7276				filter.replace( ralpha, opacity ) :
7277				filter + " " + opacity;
7278		}
7279	};
7280}
7281
7282jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,
7283	function( elem, computed ) {
7284		if ( computed ) {
7285			return swap( elem, { "display": "inline-block" },
7286				curCSS, [ elem, "marginRight" ] );
7287		}
7288	}
7289);
7290
7291jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
7292	function( elem, computed ) {
7293		if ( computed ) {
7294			return (
7295				parseFloat( curCSS( elem, "marginLeft" ) ) ||
7296
7297				// Support: IE<=11+
7298				// Running getBoundingClientRect on a disconnected node in IE throws an error
7299				// Support: IE8 only
7300				// getClientRects() errors on disconnected elems
7301				( jQuery.contains( elem.ownerDocument, elem ) ?
7302					elem.getBoundingClientRect().left -
7303						swap( elem, { marginLeft: 0 }, function() {
7304							return elem.getBoundingClientRect().left;
7305						} ) :
7306					0
7307				)
7308			) + "px";
7309		}
7310	}
7311);
7312
7313// These hooks are used by animate to expand properties
7314jQuery.each( {
7315	margin: "",
7316	padding: "",
7317	border: "Width"
7318}, function( prefix, suffix ) {
7319	jQuery.cssHooks[ prefix + suffix ] = {
7320		expand: function( value ) {
7321			var i = 0,
7322				expanded = {},
7323
7324				// assumes a single number if not a string
7325				parts = typeof value === "string" ? value.split( " " ) : [ value ];
7326
7327			for ( ; i < 4; i++ ) {
7328				expanded[ prefix + cssExpand[ i ] + suffix ] =
7329					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
7330			}
7331
7332			return expanded;
7333		}
7334	};
7335
7336	if ( !rmargin.test( prefix ) ) {
7337		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
7338	}
7339} );
7340
7341jQuery.fn.extend( {
7342	css: function( name, value ) {
7343		return access( this, function( elem, name, value ) {
7344			var styles, len,
7345				map = {},
7346				i = 0;
7347
7348			if ( jQuery.isArray( name ) ) {
7349				styles = getStyles( elem );
7350				len = name.length;
7351
7352				for ( ; i < len; i++ ) {
7353					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
7354				}
7355
7356				return map;
7357			}
7358
7359			return value !== undefined ?
7360				jQuery.style( elem, name, value ) :
7361				jQuery.css( elem, name );
7362		}, name, value, arguments.length > 1 );
7363	},
7364	show: function() {
7365		return showHide( this, true );
7366	},
7367	hide: function() {
7368		return showHide( this );
7369	},
7370	toggle: function( state ) {
7371		if ( typeof state === "boolean" ) {
7372			return state ? this.show() : this.hide();
7373		}
7374
7375		return this.each( function() {
7376			if ( isHidden( this ) ) {
7377				jQuery( this ).show();
7378			} else {
7379				jQuery( this ).hide();
7380			}
7381		} );
7382	}
7383} );
7384
7385
7386function Tween( elem, options, prop, end, easing ) {
7387	return new Tween.prototype.init( elem, options, prop, end, easing );
7388}
7389jQuery.Tween = Tween;
7390
7391Tween.prototype = {
7392	constructor: Tween,
7393	init: function( elem, options, prop, end, easing, unit ) {
7394		this.elem = elem;
7395		this.prop = prop;
7396		this.easing = easing || jQuery.easing._default;
7397		this.options = options;
7398		this.start = this.now = this.cur();
7399		this.end = end;
7400		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
7401	},
7402	cur: function() {
7403		var hooks = Tween.propHooks[ this.prop ];
7404
7405		return hooks && hooks.get ?
7406			hooks.get( this ) :
7407			Tween.propHooks._default.get( this );
7408	},
7409	run: function( percent ) {
7410		var eased,
7411			hooks = Tween.propHooks[ this.prop ];
7412
7413		if ( this.options.duration ) {
7414			this.pos = eased = jQuery.easing[ this.easing ](
7415				percent, this.options.duration * percent, 0, 1, this.options.duration
7416			);
7417		} else {
7418			this.pos = eased = percent;
7419		}
7420		this.now = ( this.end - this.start ) * eased + this.start;
7421
7422		if ( this.options.step ) {
7423			this.options.step.call( this.elem, this.now, this );
7424		}
7425
7426		if ( hooks && hooks.set ) {
7427			hooks.set( this );
7428		} else {
7429			Tween.propHooks._default.set( this );
7430		}
7431		return this;
7432	}
7433};
7434
7435Tween.prototype.init.prototype = Tween.prototype;
7436
7437Tween.propHooks = {
7438	_default: {
7439		get: function( tween ) {
7440			var result;
7441
7442			// Use a property on the element directly when it is not a DOM element,
7443			// or when there is no matching style property that exists.
7444			if ( tween.elem.nodeType !== 1 ||
7445				tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
7446				return tween.elem[ tween.prop ];
7447			}
7448
7449			// passing an empty string as a 3rd parameter to .css will automatically
7450			// attempt a parseFloat and fallback to a string if the parse fails
7451			// so, simple values such as "10px" are parsed to Float.
7452			// complex values such as "rotate(1rad)" are returned as is.
7453			result = jQuery.css( tween.elem, tween.prop, "" );
7454
7455			// Empty strings, null, undefined and "auto" are converted to 0.
7456			return !result || result === "auto" ? 0 : result;
7457		},
7458		set: function( tween ) {
7459
7460			// use step hook for back compat - use cssHook if its there - use .style if its
7461			// available and use plain properties where available
7462			if ( jQuery.fx.step[ tween.prop ] ) {
7463				jQuery.fx.step[ tween.prop ]( tween );
7464			} else if ( tween.elem.nodeType === 1 &&
7465				( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
7466					jQuery.cssHooks[ tween.prop ] ) ) {
7467				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
7468			} else {
7469				tween.elem[ tween.prop ] = tween.now;
7470			}
7471		}
7472	}
7473};
7474
7475// Support: IE <=9
7476// Panic based approach to setting things on disconnected nodes
7477
7478Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
7479	set: function( tween ) {
7480		if ( tween.elem.nodeType && tween.elem.parentNode ) {
7481			tween.elem[ tween.prop ] = tween.now;
7482		}
7483	}
7484};
7485
7486jQuery.easing = {
7487	linear: function( p ) {
7488		return p;
7489	},
7490	swing: function( p ) {
7491		return 0.5 - Math.cos( p * Math.PI ) / 2;
7492	},
7493	_default: "swing"
7494};
7495
7496jQuery.fx = Tween.prototype.init;
7497
7498// Back Compat <1.8 extension point
7499jQuery.fx.step = {};
7500
7501
7502
7503
7504var
7505	fxNow, timerId,
7506	rfxtypes = /^(?:toggle|show|hide)$/,
7507	rrun = /queueHooks$/;
7508
7509// Animations created synchronously will run synchronously
7510function createFxNow() {
7511	window.setTimeout( function() {
7512		fxNow = undefined;
7513	} );
7514	return ( fxNow = jQuery.now() );
7515}
7516
7517// Generate parameters to create a standard animation
7518function genFx( type, includeWidth ) {
7519	var which,
7520		attrs = { height: type },
7521		i = 0;
7522
7523	// if we include width, step value is 1 to do all cssExpand values,
7524	// if we don't include width, step value is 2 to skip over Left and Right
7525	includeWidth = includeWidth ? 1 : 0;
7526	for ( ; i < 4 ; i += 2 - includeWidth ) {
7527		which = cssExpand[ i ];
7528		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
7529	}
7530
7531	if ( includeWidth ) {
7532		attrs.opacity = attrs.width = type;
7533	}
7534
7535	return attrs;
7536}
7537
7538function createTween( value, prop, animation ) {
7539	var tween,
7540		collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
7541		index = 0,
7542		length = collection.length;
7543	for ( ; index < length; index++ ) {
7544		if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
7545
7546			// we're done with this property
7547			return tween;
7548		}
7549	}
7550}
7551
7552function defaultPrefilter( elem, props, opts ) {
7553	/* jshint validthis: true */
7554	var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
7555		anim = this,
7556		orig = {},
7557		style = elem.style,
7558		hidden = elem.nodeType && isHidden( elem ),
7559		dataShow = jQuery._data( elem, "fxshow" );
7560
7561	// handle queue: false promises
7562	if ( !opts.queue ) {
7563		hooks = jQuery._queueHooks( elem, "fx" );
7564		if ( hooks.unqueued == null ) {
7565			hooks.unqueued = 0;
7566			oldfire = hooks.empty.fire;
7567			hooks.empty.fire = function() {
7568				if ( !hooks.unqueued ) {
7569					oldfire();
7570				}
7571			};
7572		}
7573		hooks.unqueued++;
7574
7575		anim.always( function() {
7576
7577			// doing this makes sure that the complete handler will be called
7578			// before this completes
7579			anim.always( function() {
7580				hooks.unqueued--;
7581				if ( !jQuery.queue( elem, "fx" ).length ) {
7582					hooks.empty.fire();
7583				}
7584			} );
7585		} );
7586	}
7587
7588	// height/width overflow pass
7589	if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
7590
7591		// Make sure that nothing sneaks out
7592		// Record all 3 overflow attributes because IE does not
7593		// change the overflow attribute when overflowX and
7594		// overflowY are set to the same value
7595		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
7596
7597		// Set display property to inline-block for height/width
7598		// animations on inline elements that are having width/height animated
7599		display = jQuery.css( elem, "display" );
7600
7601		// Test default display if display is currently "none"
7602		checkDisplay = display === "none" ?
7603			jQuery._data( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display;
7604
7605		if ( checkDisplay === "inline" && jQuery.css( elem, "float" ) === "none" ) {
7606
7607			// inline-level elements accept inline-block;
7608			// block-level elements need to be inline with layout
7609			if ( !support.inlineBlockNeedsLayout || defaultDisplay( elem.nodeName ) === "inline" ) {
7610				style.display = "inline-block";
7611			} else {
7612				style.zoom = 1;
7613			}
7614		}
7615	}
7616
7617	if ( opts.overflow ) {
7618		style.overflow = "hidden";
7619		if ( !support.shrinkWrapBlocks() ) {
7620			anim.always( function() {
7621				style.overflow = opts.overflow[ 0 ];
7622				style.overflowX = opts.overflow[ 1 ];
7623				style.overflowY = opts.overflow[ 2 ];
7624			} );
7625		}
7626	}
7627
7628	// show/hide pass
7629	for ( prop in props ) {
7630		value = props[ prop ];
7631		if ( rfxtypes.exec( value ) ) {
7632			delete props[ prop ];
7633			toggle = toggle || value === "toggle";
7634			if ( value === ( hidden ? "hide" : "show" ) ) {
7635
7636				// If there is dataShow left over from a stopped hide or show
7637				// and we are going to proceed with show, we should pretend to be hidden
7638				if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
7639					hidden = true;
7640				} else {
7641					continue;
7642				}
7643			}
7644			orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
7645
7646		// Any non-fx value stops us from restoring the original display value
7647		} else {
7648			display = undefined;
7649		}
7650	}
7651
7652	if ( !jQuery.isEmptyObject( orig ) ) {
7653		if ( dataShow ) {
7654			if ( "hidden" in dataShow ) {
7655				hidden = dataShow.hidden;
7656			}
7657		} else {
7658			dataShow = jQuery._data( elem, "fxshow", {} );
7659		}
7660
7661		// store state if its toggle - enables .stop().toggle() to "reverse"
7662		if ( toggle ) {
7663			dataShow.hidden = !hidden;
7664		}
7665		if ( hidden ) {
7666			jQuery( elem ).show();
7667		} else {
7668			anim.done( function() {
7669				jQuery( elem ).hide();
7670			} );
7671		}
7672		anim.done( function() {
7673			var prop;
7674			jQuery._removeData( elem, "fxshow" );
7675			for ( prop in orig ) {
7676				jQuery.style( elem, prop, orig[ prop ] );
7677			}
7678		} );
7679		for ( prop in orig ) {
7680			tween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
7681
7682			if ( !( prop in dataShow ) ) {
7683				dataShow[ prop ] = tween.start;
7684				if ( hidden ) {
7685					tween.end = tween.start;
7686					tween.start = prop === "width" || prop === "height" ? 1 : 0;
7687				}
7688			}
7689		}
7690
7691	// If this is a noop like .hide().hide(), restore an overwritten display value
7692	} else if ( ( display === "none" ? defaultDisplay( elem.nodeName ) : display ) === "inline" ) {
7693		style.display = display;
7694	}
7695}
7696
7697function propFilter( props, specialEasing ) {
7698	var index, name, easing, value, hooks;
7699
7700	// camelCase, specialEasing and expand cssHook pass
7701	for ( index in props ) {
7702		name = jQuery.camelCase( index );
7703		easing = specialEasing[ name ];
7704		value = props[ index ];
7705		if ( jQuery.isArray( value ) ) {
7706			easing = value[ 1 ];
7707			value = props[ index ] = value[ 0 ];
7708		}
7709
7710		if ( index !== name ) {
7711			props[ name ] = value;
7712			delete props[ index ];
7713		}
7714
7715		hooks = jQuery.cssHooks[ name ];
7716		if ( hooks && "expand" in hooks ) {
7717			value = hooks.expand( value );
7718			delete props[ name ];
7719
7720			// not quite $.extend, this wont overwrite keys already present.
7721			// also - reusing 'index' from above because we have the correct "name"
7722			for ( index in value ) {
7723				if ( !( index in props ) ) {
7724					props[ index ] = value[ index ];
7725					specialEasing[ index ] = easing;
7726				}
7727			}
7728		} else {
7729			specialEasing[ name ] = easing;
7730		}
7731	}
7732}
7733
7734function Animation( elem, properties, options ) {
7735	var result,
7736		stopped,
7737		index = 0,
7738		length = Animation.prefilters.length,
7739		deferred = jQuery.Deferred().always( function() {
7740
7741			// don't match elem in the :animated selector
7742			delete tick.elem;
7743		} ),
7744		tick = function() {
7745			if ( stopped ) {
7746				return false;
7747			}
7748			var currentTime = fxNow || createFxNow(),
7749				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
7750
7751				// Support: Android 2.3
7752				// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
7753				temp = remaining / animation.duration || 0,
7754				percent = 1 - temp,
7755				index = 0,
7756				length = animation.tweens.length;
7757
7758			for ( ; index < length ; index++ ) {
7759				animation.tweens[ index ].run( percent );
7760			}
7761
7762			deferred.notifyWith( elem, [ animation, percent, remaining ] );
7763
7764			if ( percent < 1 && length ) {
7765				return remaining;
7766			} else {
7767				deferred.resolveWith( elem, [ animation ] );
7768				return false;
7769			}
7770		},
7771		animation = deferred.promise( {
7772			elem: elem,
7773			props: jQuery.extend( {}, properties ),
7774			opts: jQuery.extend( true, {
7775				specialEasing: {},
7776				easing: jQuery.easing._default
7777			}, options ),
7778			originalProperties: properties,
7779			originalOptions: options,
7780			startTime: fxNow || createFxNow(),
7781			duration: options.duration,
7782			tweens: [],
7783			createTween: function( prop, end ) {
7784				var tween = jQuery.Tween( elem, animation.opts, prop, end,
7785						animation.opts.specialEasing[ prop ] || animation.opts.easing );
7786				animation.tweens.push( tween );
7787				return tween;
7788			},
7789			stop: function( gotoEnd ) {
7790				var index = 0,
7791
7792					// if we are going to the end, we want to run all the tweens
7793					// otherwise we skip this part
7794					length = gotoEnd ? animation.tweens.length : 0;
7795				if ( stopped ) {
7796					return this;
7797				}
7798				stopped = true;
7799				for ( ; index < length ; index++ ) {
7800					animation.tweens[ index ].run( 1 );
7801				}
7802
7803				// resolve when we played the last frame
7804				// otherwise, reject
7805				if ( gotoEnd ) {
7806					deferred.notifyWith( elem, [ animation, 1, 0 ] );
7807					deferred.resolveWith( elem, [ animation, gotoEnd ] );
7808				} else {
7809					deferred.rejectWith( elem, [ animation, gotoEnd ] );
7810				}
7811				return this;
7812			}
7813		} ),
7814		props = animation.props;
7815
7816	propFilter( props, animation.opts.specialEasing );
7817
7818	for ( ; index < length ; index++ ) {
7819		result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
7820		if ( result ) {
7821			if ( jQuery.isFunction( result.stop ) ) {
7822				jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
7823					jQuery.proxy( result.stop, result );
7824			}
7825			return result;
7826		}
7827	}
7828
7829	jQuery.map( props, createTween, animation );
7830
7831	if ( jQuery.isFunction( animation.opts.start ) ) {
7832		animation.opts.start.call( elem, animation );
7833	}
7834
7835	jQuery.fx.timer(
7836		jQuery.extend( tick, {
7837			elem: elem,
7838			anim: animation,
7839			queue: animation.opts.queue
7840		} )
7841	);
7842
7843	// attach callbacks from options
7844	return animation.progress( animation.opts.progress )
7845		.done( animation.opts.done, animation.opts.complete )
7846		.fail( animation.opts.fail )
7847		.always( animation.opts.always );
7848}
7849
7850jQuery.Animation = jQuery.extend( Animation, {
7851
7852	tweeners: {
7853		"*": [ function( prop, value ) {
7854			var tween = this.createTween( prop, value );
7855			adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
7856			return tween;
7857		} ]
7858	},
7859
7860	tweener: function( props, callback ) {
7861		if ( jQuery.isFunction( props ) ) {
7862			callback = props;
7863			props = [ "*" ];
7864		} else {
7865			props = props.match( rnotwhite );
7866		}
7867
7868		var prop,
7869			index = 0,
7870			length = props.length;
7871
7872		for ( ; index < length ; index++ ) {
7873			prop = props[ index ];
7874			Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
7875			Animation.tweeners[ prop ].unshift( callback );
7876		}
7877	},
7878
7879	prefilters: [ defaultPrefilter ],
7880
7881	prefilter: function( callback, prepend ) {
7882		if ( prepend ) {
7883			Animation.prefilters.unshift( callback );
7884		} else {
7885			Animation.prefilters.push( callback );
7886		}
7887	}
7888} );
7889
7890jQuery.speed = function( speed, easing, fn ) {
7891	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
7892		complete: fn || !fn && easing ||
7893			jQuery.isFunction( speed ) && speed,
7894		duration: speed,
7895		easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
7896	};
7897
7898	opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
7899		opt.duration in jQuery.fx.speeds ?
7900			jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
7901
7902	// normalize opt.queue - true/undefined/null -> "fx"
7903	if ( opt.queue == null || opt.queue === true ) {
7904		opt.queue = "fx";
7905	}
7906
7907	// Queueing
7908	opt.old = opt.complete;
7909
7910	opt.complete = function() {
7911		if ( jQuery.isFunction( opt.old ) ) {
7912			opt.old.call( this );
7913		}
7914
7915		if ( opt.queue ) {
7916			jQuery.dequeue( this, opt.queue );
7917		}
7918	};
7919
7920	return opt;
7921};
7922
7923jQuery.fn.extend( {
7924	fadeTo: function( speed, to, easing, callback ) {
7925
7926		// show any hidden elements after setting opacity to 0
7927		return this.filter( isHidden ).css( "opacity", 0 ).show()
7928
7929			// animate to the value specified
7930			.end().animate( { opacity: to }, speed, easing, callback );
7931	},
7932	animate: function( prop, speed, easing, callback ) {
7933		var empty = jQuery.isEmptyObject( prop ),
7934			optall = jQuery.speed( speed, easing, callback ),
7935			doAnimation = function() {
7936
7937				// Operate on a copy of prop so per-property easing won't be lost
7938				var anim = Animation( this, jQuery.extend( {}, prop ), optall );
7939
7940				// Empty animations, or finishing resolves immediately
7941				if ( empty || jQuery._data( this, "finish" ) ) {
7942					anim.stop( true );
7943				}
7944			};
7945			doAnimation.finish = doAnimation;
7946
7947		return empty || optall.queue === false ?
7948			this.each( doAnimation ) :
7949			this.queue( optall.queue, doAnimation );
7950	},
7951	stop: function( type, clearQueue, gotoEnd ) {
7952		var stopQueue = function( hooks ) {
7953			var stop = hooks.stop;
7954			delete hooks.stop;
7955			stop( gotoEnd );
7956		};
7957
7958		if ( typeof type !== "string" ) {
7959			gotoEnd = clearQueue;
7960			clearQueue = type;
7961			type = undefined;
7962		}
7963		if ( clearQueue && type !== false ) {
7964			this.queue( type || "fx", [] );
7965		}
7966
7967		return this.each( function() {
7968			var dequeue = true,
7969				index = type != null && type + "queueHooks",
7970				timers = jQuery.timers,
7971				data = jQuery._data( this );
7972
7973			if ( index ) {
7974				if ( data[ index ] && data[ index ].stop ) {
7975					stopQueue( data[ index ] );
7976				}
7977			} else {
7978				for ( index in data ) {
7979					if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
7980						stopQueue( data[ index ] );
7981					}
7982				}
7983			}
7984
7985			for ( index = timers.length; index--; ) {
7986				if ( timers[ index ].elem === this &&
7987					( type == null || timers[ index ].queue === type ) ) {
7988
7989					timers[ index ].anim.stop( gotoEnd );
7990					dequeue = false;
7991					timers.splice( index, 1 );
7992				}
7993			}
7994
7995			// start the next in the queue if the last step wasn't forced
7996			// timers currently will call their complete callbacks, which will dequeue
7997			// but only if they were gotoEnd
7998			if ( dequeue || !gotoEnd ) {
7999				jQuery.dequeue( this, type );
8000			}
8001		} );
8002	},
8003	finish: function( type ) {
8004		if ( type !== false ) {
8005			type = type || "fx";
8006		}
8007		return this.each( function() {
8008			var index,
8009				data = jQuery._data( this ),
8010				queue = data[ type + "queue" ],
8011				hooks = data[ type + "queueHooks" ],
8012				timers = jQuery.timers,
8013				length = queue ? queue.length : 0;
8014
8015			// enable finishing flag on private data
8016			data.finish = true;
8017
8018			// empty the queue first
8019			jQuery.queue( this, type, [] );
8020
8021			if ( hooks && hooks.stop ) {
8022				hooks.stop.call( this, true );
8023			}
8024
8025			// look for any active animations, and finish them
8026			for ( index = timers.length; index--; ) {
8027				if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
8028					timers[ index ].anim.stop( true );
8029					timers.splice( index, 1 );
8030				}
8031			}
8032
8033			// look for any animations in the old queue and finish them
8034			for ( index = 0; index < length; index++ ) {
8035				if ( queue[ index ] && queue[ index ].finish ) {
8036					queue[ index ].finish.call( this );
8037				}
8038			}
8039
8040			// turn off finishing flag
8041			delete data.finish;
8042		} );
8043	}
8044} );
8045
8046jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
8047	var cssFn = jQuery.fn[ name ];
8048	jQuery.fn[ name ] = function( speed, easing, callback ) {
8049		return speed == null || typeof speed === "boolean" ?
8050			cssFn.apply( this, arguments ) :
8051			this.animate( genFx( name, true ), speed, easing, callback );
8052	};
8053} );
8054
8055// Generate shortcuts for custom animations
8056jQuery.each( {
8057	slideDown: genFx( "show" ),
8058	slideUp: genFx( "hide" ),
8059	slideToggle: genFx( "toggle" ),
8060	fadeIn: { opacity: "show" },
8061	fadeOut: { opacity: "hide" },
8062	fadeToggle: { opacity: "toggle" }
8063}, function( name, props ) {
8064	jQuery.fn[ name ] = function( speed, easing, callback ) {
8065		return this.animate( props, speed, easing, callback );
8066	};
8067} );
8068
8069jQuery.timers = [];
8070jQuery.fx.tick = function() {
8071	var timer,
8072		timers = jQuery.timers,
8073		i = 0;
8074
8075	fxNow = jQuery.now();
8076
8077	for ( ; i < timers.length; i++ ) {
8078		timer = timers[ i ];
8079
8080		// Checks the timer has not already been removed
8081		if ( !timer() && timers[ i ] === timer ) {
8082			timers.splice( i--, 1 );
8083		}
8084	}
8085
8086	if ( !timers.length ) {
8087		jQuery.fx.stop();
8088	}
8089	fxNow = undefined;
8090};
8091
8092jQuery.fx.timer = function( timer ) {
8093	jQuery.timers.push( timer );
8094	if ( timer() ) {
8095		jQuery.fx.start();
8096	} else {
8097		jQuery.timers.pop();
8098	}
8099};
8100
8101jQuery.fx.interval = 13;
8102
8103jQuery.fx.start = function() {
8104	if ( !timerId ) {
8105		timerId = window.setInterval( jQuery.fx.tick, jQuery.fx.interval );
8106	}
8107};
8108
8109jQuery.fx.stop = function() {
8110	window.clearInterval( timerId );
8111	timerId = null;
8112};
8113
8114jQuery.fx.speeds = {
8115	slow: 600,
8116	fast: 200,
8117
8118	// Default speed
8119	_default: 400
8120};
8121
8122
8123// Based off of the plugin by Clint Helfers, with permission.
8124// http://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
8125jQuery.fn.delay = function( time, type ) {
8126	time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
8127	type = type || "fx";
8128
8129	return this.queue( type, function( next, hooks ) {
8130		var timeout = window.setTimeout( next, time );
8131		hooks.stop = function() {
8132			window.clearTimeout( timeout );
8133		};
8134	} );
8135};
8136
8137
8138( function() {
8139	var a,
8140		input = document.createElement( "input" ),
8141		div = document.createElement( "div" ),
8142		select = document.createElement( "select" ),
8143		opt = select.appendChild( document.createElement( "option" ) );
8144
8145	// Setup
8146	div = document.createElement( "div" );
8147	div.setAttribute( "className", "t" );
8148	div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
8149	a = div.getElementsByTagName( "a" )[ 0 ];
8150
8151	// Support: Windows Web Apps (WWA)
8152	// `type` must use .setAttribute for WWA (#14901)
8153	input.setAttribute( "type", "checkbox" );
8154	div.appendChild( input );
8155
8156	a = div.getElementsByTagName( "a" )[ 0 ];
8157
8158	// First batch of tests.
8159	a.style.cssText = "top:1px";
8160
8161	// Test setAttribute on camelCase class.
8162	// If it works, we need attrFixes when doing get/setAttribute (ie6/7)
8163	support.getSetAttribute = div.className !== "t";
8164
8165	// Get the style information from getAttribute
8166	// (IE uses .cssText instead)
8167	support.style = /top/.test( a.getAttribute( "style" ) );
8168
8169	// Make sure that URLs aren't manipulated
8170	// (IE normalizes it by default)
8171	support.hrefNormalized = a.getAttribute( "href" ) === "/a";
8172
8173	// Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
8174	support.checkOn = !!input.value;
8175
8176	// Make sure that a selected-by-default option has a working selected property.
8177	// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
8178	support.optSelected = opt.selected;
8179
8180	// Tests for enctype support on a form (#6743)
8181	support.enctype = !!document.createElement( "form" ).enctype;
8182
8183	// Make sure that the options inside disabled selects aren't marked as disabled
8184	// (WebKit marks them as disabled)
8185	select.disabled = true;
8186	support.optDisabled = !opt.disabled;
8187
8188	// Support: IE8 only
8189	// Check if we can trust getAttribute("value")
8190	input = document.createElement( "input" );
8191	input.setAttribute( "value", "" );
8192	support.input = input.getAttribute( "value" ) === "";
8193
8194	// Check if an input maintains its value after becoming a radio
8195	input.value = "t";
8196	input.setAttribute( "type", "radio" );
8197	support.radioValue = input.value === "t";
8198} )();
8199
8200
8201var rreturn = /\r/g,
8202	rspaces = /[\x20\t\r\n\f]+/g;
8203
8204jQuery.fn.extend( {
8205	val: function( value ) {
8206		var hooks, ret, isFunction,
8207			elem = this[ 0 ];
8208
8209		if ( !arguments.length ) {
8210			if ( elem ) {
8211				hooks = jQuery.valHooks[ elem.type ] ||
8212					jQuery.valHooks[ elem.nodeName.toLowerCase() ];
8213
8214				if (
8215					hooks &&
8216					"get" in hooks &&
8217					( ret = hooks.get( elem, "value" ) ) !== undefined
8218				) {
8219					return ret;
8220				}
8221
8222				ret = elem.value;
8223
8224				return typeof ret === "string" ?
8225
8226					// handle most common string cases
8227					ret.replace( rreturn, "" ) :
8228
8229					// handle cases where value is null/undef or number
8230					ret == null ? "" : ret;
8231			}
8232
8233			return;
8234		}
8235
8236		isFunction = jQuery.isFunction( value );
8237
8238		return this.each( function( i ) {
8239			var val;
8240
8241			if ( this.nodeType !== 1 ) {
8242				return;
8243			}
8244
8245			if ( isFunction ) {
8246				val = value.call( this, i, jQuery( this ).val() );
8247			} else {
8248				val = value;
8249			}
8250
8251			// Treat null/undefined as ""; convert numbers to string
8252			if ( val == null ) {
8253				val = "";
8254			} else if ( typeof val === "number" ) {
8255				val += "";
8256			} else if ( jQuery.isArray( val ) ) {
8257				val = jQuery.map( val, function( value ) {
8258					return value == null ? "" : value + "";
8259				} );
8260			}
8261
8262			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
8263
8264			// If set returns undefined, fall back to normal setting
8265			if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
8266				this.value = val;
8267			}
8268		} );
8269	}
8270} );
8271
8272jQuery.extend( {
8273	valHooks: {
8274		option: {
8275			get: function( elem ) {
8276				var val = jQuery.find.attr( elem, "value" );
8277				return val != null ?
8278					val :
8279
8280					// Support: IE10-11+
8281					// option.text throws exceptions (#14686, #14858)
8282					// Strip and collapse whitespace
8283					// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
8284					jQuery.trim( jQuery.text( elem ) ).replace( rspaces, " " );
8285			}
8286		},
8287		select: {
8288			get: function( elem ) {
8289				var value, option,
8290					options = elem.options,
8291					index = elem.selectedIndex,
8292					one = elem.type === "select-one" || index < 0,
8293					values = one ? null : [],
8294					max = one ? index + 1 : options.length,
8295					i = index < 0 ?
8296						max :
8297						one ? index : 0;
8298
8299				// Loop through all the selected options
8300				for ( ; i < max; i++ ) {
8301					option = options[ i ];
8302
8303					// oldIE doesn't update selected after form reset (#2551)
8304					if ( ( option.selected || i === index ) &&
8305
8306							// Don't return options that are disabled or in a disabled optgroup
8307							( support.optDisabled ?
8308								!option.disabled :
8309								option.getAttribute( "disabled" ) === null ) &&
8310							( !option.parentNode.disabled ||
8311								!jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
8312
8313						// Get the specific value for the option
8314						value = jQuery( option ).val();
8315
8316						// We don't need an array for one selects
8317						if ( one ) {
8318							return value;
8319						}
8320
8321						// Multi-Selects return an array
8322						values.push( value );
8323					}
8324				}
8325
8326				return values;
8327			},
8328
8329			set: function( elem, value ) {
8330				var optionSet, option,
8331					options = elem.options,
8332					values = jQuery.makeArray( value ),
8333					i = options.length;
8334
8335				while ( i-- ) {
8336					option = options[ i ];
8337
8338					if ( jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 ) {
8339
8340						// Support: IE6
8341						// When new option element is added to select box we need to
8342						// force reflow of newly added node in order to workaround delay
8343						// of initialization properties
8344						try {
8345							option.selected = optionSet = true;
8346
8347						} catch ( _ ) {
8348
8349							// Will be executed only in IE6
8350							option.scrollHeight;
8351						}
8352
8353					} else {
8354						option.selected = false;
8355					}
8356				}
8357
8358				// Force browsers to behave consistently when non-matching value is set
8359				if ( !optionSet ) {
8360					elem.selectedIndex = -1;
8361				}
8362
8363				return options;
8364			}
8365		}
8366	}
8367} );
8368
8369// Radios and checkboxes getter/setter
8370jQuery.each( [ "radio", "checkbox" ], function() {
8371	jQuery.valHooks[ this ] = {
8372		set: function( elem, value ) {
8373			if ( jQuery.isArray( value ) ) {
8374				return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
8375			}
8376		}
8377	};
8378	if ( !support.checkOn ) {
8379		jQuery.valHooks[ this ].get = function( elem ) {
8380			return elem.getAttribute( "value" ) === null ? "on" : elem.value;
8381		};
8382	}
8383} );
8384
8385
8386
8387
8388var nodeHook, boolHook,
8389	attrHandle = jQuery.expr.attrHandle,
8390	ruseDefault = /^(?:checked|selected)$/i,
8391	getSetAttribute = support.getSetAttribute,
8392	getSetInput = support.input;
8393
8394jQuery.fn.extend( {
8395	attr: function( name, value ) {
8396		return access( this, jQuery.attr, name, value, arguments.length > 1 );
8397	},
8398
8399	removeAttr: function( name ) {
8400		return this.each( function() {
8401			jQuery.removeAttr( this, name );
8402		} );
8403	}
8404} );
8405
8406jQuery.extend( {
8407	attr: function( elem, name, value ) {
8408		var ret, hooks,
8409			nType = elem.nodeType;
8410
8411		// Don't get/set attributes on text, comment and attribute nodes
8412		if ( nType === 3 || nType === 8 || nType === 2 ) {
8413			return;
8414		}
8415
8416		// Fallback to prop when attributes are not supported
8417		if ( typeof elem.getAttribute === "undefined" ) {
8418			return jQuery.prop( elem, name, value );
8419		}
8420
8421		// All attributes are lowercase
8422		// Grab necessary hook if one is defined
8423		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
8424			name = name.toLowerCase();
8425			hooks = jQuery.attrHooks[ name ] ||
8426				( jQuery.expr.match.bool.test( name ) ? boolHook : nodeHook );
8427		}
8428
8429		if ( value !== undefined ) {
8430			if ( value === null ) {
8431				jQuery.removeAttr( elem, name );
8432				return;
8433			}
8434
8435			if ( hooks && "set" in hooks &&
8436				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
8437				return ret;
8438			}
8439
8440			elem.setAttribute( name, value + "" );
8441			return value;
8442		}
8443
8444		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
8445			return ret;
8446		}
8447
8448		ret = jQuery.find.attr( elem, name );
8449
8450		// Non-existent attributes return null, we normalize to undefined
8451		return ret == null ? undefined : ret;
8452	},
8453
8454	attrHooks: {
8455		type: {
8456			set: function( elem, value ) {
8457				if ( !support.radioValue && value === "radio" &&
8458					jQuery.nodeName( elem, "input" ) ) {
8459
8460					// Setting the type on a radio button after the value resets the value in IE8-9
8461					// Reset value to default in case type is set after value during creation
8462					var val = elem.value;
8463					elem.setAttribute( "type", value );
8464					if ( val ) {
8465						elem.value = val;
8466					}
8467					return value;
8468				}
8469			}
8470		}
8471	},
8472
8473	removeAttr: function( elem, value ) {
8474		var name, propName,
8475			i = 0,
8476			attrNames = value && value.match( rnotwhite );
8477
8478		if ( attrNames && elem.nodeType === 1 ) {
8479			while ( ( name = attrNames[ i++ ] ) ) {
8480				propName = jQuery.propFix[ name ] || name;
8481
8482				// Boolean attributes get special treatment (#10870)
8483				if ( jQuery.expr.match.bool.test( name ) ) {
8484
8485					// Set corresponding property to false
8486					if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
8487						elem[ propName ] = false;
8488
8489					// Support: IE<9
8490					// Also clear defaultChecked/defaultSelected (if appropriate)
8491					} else {
8492						elem[ jQuery.camelCase( "default-" + name ) ] =
8493							elem[ propName ] = false;
8494					}
8495
8496				// See #9699 for explanation of this approach (setting first, then removal)
8497				} else {
8498					jQuery.attr( elem, name, "" );
8499				}
8500
8501				elem.removeAttribute( getSetAttribute ? name : propName );
8502			}
8503		}
8504	}
8505} );
8506
8507// Hooks for boolean attributes
8508boolHook = {
8509	set: function( elem, value, name ) {
8510		if ( value === false ) {
8511
8512			// Remove boolean attributes when set to false
8513			jQuery.removeAttr( elem, name );
8514		} else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
8515
8516			// IE<8 needs the *property* name
8517			elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name );
8518
8519		} else {
8520
8521			// Support: IE<9
8522			// Use defaultChecked and defaultSelected for oldIE
8523			elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true;
8524		}
8525		return name;
8526	}
8527};
8528
8529jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
8530	var getter = attrHandle[ name ] || jQuery.find.attr;
8531
8532	if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
8533		attrHandle[ name ] = function( elem, name, isXML ) {
8534			var ret, handle;
8535			if ( !isXML ) {
8536
8537				// Avoid an infinite loop by temporarily removing this function from the getter
8538				handle = attrHandle[ name ];
8539				attrHandle[ name ] = ret;
8540				ret = getter( elem, name, isXML ) != null ?
8541					name.toLowerCase() :
8542					null;
8543				attrHandle[ name ] = handle;
8544			}
8545			return ret;
8546		};
8547	} else {
8548		attrHandle[ name ] = function( elem, name, isXML ) {
8549			if ( !isXML ) {
8550				return elem[ jQuery.camelCase( "default-" + name ) ] ?
8551					name.toLowerCase() :
8552					null;
8553			}
8554		};
8555	}
8556} );
8557
8558// fix oldIE attroperties
8559if ( !getSetInput || !getSetAttribute ) {
8560	jQuery.attrHooks.value = {
8561		set: function( elem, value, name ) {
8562			if ( jQuery.nodeName( elem, "input" ) ) {
8563
8564				// Does not return so that setAttribute is also used
8565				elem.defaultValue = value;
8566			} else {
8567
8568				// Use nodeHook if defined (#1954); otherwise setAttribute is fine
8569				return nodeHook && nodeHook.set( elem, value, name );
8570			}
8571		}
8572	};
8573}
8574
8575// IE6/7 do not support getting/setting some attributes with get/setAttribute
8576if ( !getSetAttribute ) {
8577
8578	// Use this for any attribute in IE6/7
8579	// This fixes almost every IE6/7 issue
8580	nodeHook = {
8581		set: function( elem, value, name ) {
8582
8583			// Set the existing or create a new attribute node
8584			var ret = elem.getAttributeNode( name );
8585			if ( !ret ) {
8586				elem.setAttributeNode(
8587					( ret = elem.ownerDocument.createAttribute( name ) )
8588				);
8589			}
8590
8591			ret.value = value += "";
8592
8593			// Break association with cloned elements by also using setAttribute (#9646)
8594			if ( name === "value" || value === elem.getAttribute( name ) ) {
8595				return value;
8596			}
8597		}
8598	};
8599
8600	// Some attributes are constructed with empty-string values when not defined
8601	attrHandle.id = attrHandle.name = attrHandle.coords =
8602		function( elem, name, isXML ) {
8603			var ret;
8604			if ( !isXML ) {
8605				return ( ret = elem.getAttributeNode( name ) ) && ret.value !== "" ?
8606					ret.value :
8607					null;
8608			}
8609		};
8610
8611	// Fixing value retrieval on a button requires this module
8612	jQuery.valHooks.button = {
8613		get: function( elem, name ) {
8614			var ret = elem.getAttributeNode( name );
8615			if ( ret && ret.specified ) {
8616				return ret.value;
8617			}
8618		},
8619		set: nodeHook.set
8620	};
8621
8622	// Set contenteditable to false on removals(#10429)
8623	// Setting to empty string throws an error as an invalid value
8624	jQuery.attrHooks.contenteditable = {
8625		set: function( elem, value, name ) {
8626			nodeHook.set( elem, value === "" ? false : value, name );
8627		}
8628	};
8629
8630	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
8631	// This is for removals
8632	jQuery.each( [ "width", "height" ], function( i, name ) {
8633		jQuery.attrHooks[ name ] = {
8634			set: function( elem, value ) {
8635				if ( value === "" ) {
8636					elem.setAttribute( name, "auto" );
8637					return value;
8638				}
8639			}
8640		};
8641	} );
8642}
8643
8644if ( !support.style ) {
8645	jQuery.attrHooks.style = {
8646		get: function( elem ) {
8647
8648			// Return undefined in the case of empty string
8649			// Note: IE uppercases css property names, but if we were to .toLowerCase()
8650			// .cssText, that would destroy case sensitivity in URL's, like in "background"
8651			return elem.style.cssText || undefined;
8652		},
8653		set: function( elem, value ) {
8654			return ( elem.style.cssText = value + "" );
8655		}
8656	};
8657}
8658
8659
8660
8661
8662var rfocusable = /^(?:input|select|textarea|button|object)$/i,
8663	rclickable = /^(?:a|area)$/i;
8664
8665jQuery.fn.extend( {
8666	prop: function( name, value ) {
8667		return access( this, jQuery.prop, name, value, arguments.length > 1 );
8668	},
8669
8670	removeProp: function( name ) {
8671		name = jQuery.propFix[ name ] || name;
8672		return this.each( function() {
8673
8674			// try/catch handles cases where IE balks (such as removing a property on window)
8675			try {
8676				this[ name ] = undefined;
8677				delete this[ name ];
8678			} catch ( e ) {}
8679		} );
8680	}
8681} );
8682
8683jQuery.extend( {
8684	prop: function( elem, name, value ) {
8685		var ret, hooks,
8686			nType = elem.nodeType;
8687
8688		// Don't get/set properties on text, comment and attribute nodes
8689		if ( nType === 3 || nType === 8 || nType === 2 ) {
8690			return;
8691		}
8692
8693		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
8694
8695			// Fix name and attach hooks
8696			name = jQuery.propFix[ name ] || name;
8697			hooks = jQuery.propHooks[ name ];
8698		}
8699
8700		if ( value !== undefined ) {
8701			if ( hooks && "set" in hooks &&
8702				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
8703				return ret;
8704			}
8705
8706			return ( elem[ name ] = value );
8707		}
8708
8709		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
8710			return ret;
8711		}
8712
8713		return elem[ name ];
8714	},
8715
8716	propHooks: {
8717		tabIndex: {
8718			get: function( elem ) {
8719
8720				// elem.tabIndex doesn't always return the
8721				// correct value when it hasn't been explicitly set
8722				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
8723				// Use proper attribute retrieval(#12072)
8724				var tabindex = jQuery.find.attr( elem, "tabindex" );
8725
8726				return tabindex ?
8727					parseInt( tabindex, 10 ) :
8728					rfocusable.test( elem.nodeName ) ||
8729						rclickable.test( elem.nodeName ) && elem.href ?
8730							0 :
8731							-1;
8732			}
8733		}
8734	},
8735
8736	propFix: {
8737		"for": "htmlFor",
8738		"class": "className"
8739	}
8740} );
8741
8742// Some attributes require a special call on IE
8743// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
8744if ( !support.hrefNormalized ) {
8745
8746	// href/src property should get the full normalized URL (#10299/#12915)
8747	jQuery.each( [ "href", "src" ], function( i, name ) {
8748		jQuery.propHooks[ name ] = {
8749			get: function( elem ) {
8750				return elem.getAttribute( name, 4 );
8751			}
8752		};
8753	} );
8754}
8755
8756// Support: Safari, IE9+
8757// Accessing the selectedIndex property
8758// forces the browser to respect setting selected
8759// on the option
8760// The getter ensures a default option is selected
8761// when in an optgroup
8762if ( !support.optSelected ) {
8763	jQuery.propHooks.selected = {
8764		get: function( elem ) {
8765			var parent = elem.parentNode;
8766
8767			if ( parent ) {
8768				parent.selectedIndex;
8769
8770				// Make sure that it also works with optgroups, see #5701
8771				if ( parent.parentNode ) {
8772					parent.parentNode.selectedIndex;
8773				}
8774			}
8775			return null;
8776		},
8777		set: function( elem ) {
8778			var parent = elem.parentNode;
8779			if ( parent ) {
8780				parent.selectedIndex;
8781
8782				if ( parent.parentNode ) {
8783					parent.parentNode.selectedIndex;
8784				}
8785			}
8786		}
8787	};
8788}
8789
8790jQuery.each( [
8791	"tabIndex",
8792	"readOnly",
8793	"maxLength",
8794	"cellSpacing",
8795	"cellPadding",
8796	"rowSpan",
8797	"colSpan",
8798	"useMap",
8799	"frameBorder",
8800	"contentEditable"
8801], function() {
8802	jQuery.propFix[ this.toLowerCase() ] = this;
8803} );
8804
8805// IE6/7 call enctype encoding
8806if ( !support.enctype ) {
8807	jQuery.propFix.enctype = "encoding";
8808}
8809
8810
8811
8812
8813var rclass = /[\t\r\n\f]/g;
8814
8815function getClass( elem ) {
8816	return jQuery.attr( elem, "class" ) || "";
8817}
8818
8819jQuery.fn.extend( {
8820	addClass: function( value ) {
8821		var classes, elem, cur, curValue, clazz, j, finalValue,
8822			i = 0;
8823
8824		if ( jQuery.isFunction( value ) ) {
8825			return this.each( function( j ) {
8826				jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
8827			} );
8828		}
8829
8830		if ( typeof value === "string" && value ) {
8831			classes = value.match( rnotwhite ) || [];
8832
8833			while ( ( elem = this[ i++ ] ) ) {
8834				curValue = getClass( elem );
8835				cur = elem.nodeType === 1 &&
8836					( " " + curValue + " " ).replace( rclass, " " );
8837
8838				if ( cur ) {
8839					j = 0;
8840					while ( ( clazz = classes[ j++ ] ) ) {
8841						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
8842							cur += clazz + " ";
8843						}
8844					}
8845
8846					// only assign if different to avoid unneeded rendering.
8847					finalValue = jQuery.trim( cur );
8848					if ( curValue !== finalValue ) {
8849						jQuery.attr( elem, "class", finalValue );
8850					}
8851				}
8852			}
8853		}
8854
8855		return this;
8856	},
8857
8858	removeClass: function( value ) {
8859		var classes, elem, cur, curValue, clazz, j, finalValue,
8860			i = 0;
8861
8862		if ( jQuery.isFunction( value ) ) {
8863			return this.each( function( j ) {
8864				jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
8865			} );
8866		}
8867
8868		if ( !arguments.length ) {
8869			return this.attr( "class", "" );
8870		}
8871
8872		if ( typeof value === "string" && value ) {
8873			classes = value.match( rnotwhite ) || [];
8874
8875			while ( ( elem = this[ i++ ] ) ) {
8876				curValue = getClass( elem );
8877
8878				// This expression is here for better compressibility (see addClass)
8879				cur = elem.nodeType === 1 &&
8880					( " " + curValue + " " ).replace( rclass, " " );
8881
8882				if ( cur ) {
8883					j = 0;
8884					while ( ( clazz = classes[ j++ ] ) ) {
8885
8886						// Remove *all* instances
8887						while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
8888							cur = cur.replace( " " + clazz + " ", " " );
8889						}
8890					}
8891
8892					// Only assign if different to avoid unneeded rendering.
8893					finalValue = jQuery.trim( cur );
8894					if ( curValue !== finalValue ) {
8895						jQuery.attr( elem, "class", finalValue );
8896					}
8897				}
8898			}
8899		}
8900
8901		return this;
8902	},
8903
8904	toggleClass: function( value, stateVal ) {
8905		var type = typeof value;
8906
8907		if ( typeof stateVal === "boolean" && type === "string" ) {
8908			return stateVal ? this.addClass( value ) : this.removeClass( value );
8909		}
8910
8911		if ( jQuery.isFunction( value ) ) {
8912			return this.each( function( i ) {
8913				jQuery( this ).toggleClass(
8914					value.call( this, i, getClass( this ), stateVal ),
8915					stateVal
8916				);
8917			} );
8918		}
8919
8920		return this.each( function() {
8921			var className, i, self, classNames;
8922
8923			if ( type === "string" ) {
8924
8925				// Toggle individual class names
8926				i = 0;
8927				self = jQuery( this );
8928				classNames = value.match( rnotwhite ) || [];
8929
8930				while ( ( className = classNames[ i++ ] ) ) {
8931
8932					// Check each className given, space separated list
8933					if ( self.hasClass( className ) ) {
8934						self.removeClass( className );
8935					} else {
8936						self.addClass( className );
8937					}
8938				}
8939
8940			// Toggle whole class name
8941			} else if ( value === undefined || type === "boolean" ) {
8942				className = getClass( this );
8943				if ( className ) {
8944
8945					// store className if set
8946					jQuery._data( this, "__className__", className );
8947				}
8948
8949				// If the element has a class name or if we're passed "false",
8950				// then remove the whole classname (if there was one, the above saved it).
8951				// Otherwise bring back whatever was previously saved (if anything),
8952				// falling back to the empty string if nothing was stored.
8953				jQuery.attr( this, "class",
8954					className || value === false ?
8955					"" :
8956					jQuery._data( this, "__className__" ) || ""
8957				);
8958			}
8959		} );
8960	},
8961
8962	hasClass: function( selector ) {
8963		var className, elem,
8964			i = 0;
8965
8966		className = " " + selector + " ";
8967		while ( ( elem = this[ i++ ] ) ) {
8968			if ( elem.nodeType === 1 &&
8969				( " " + getClass( elem ) + " " ).replace( rclass, " " )
8970					.indexOf( className ) > -1
8971			) {
8972				return true;
8973			}
8974		}
8975
8976		return false;
8977	}
8978} );
8979
8980
8981
8982
8983// Return jQuery for attributes-only inclusion
8984
8985
8986jQuery.each( ( "blur focus focusin focusout load resize scroll unload click dblclick " +
8987	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
8988	"change select submit keydown keypress keyup error contextmenu" ).split( " " ),
8989	function( i, name ) {
8990
8991	// Handle event binding
8992	jQuery.fn[ name ] = function( data, fn ) {
8993		return arguments.length > 0 ?
8994			this.on( name, null, data, fn ) :
8995			this.trigger( name );
8996	};
8997} );
8998
8999jQuery.fn.extend( {
9000	hover: function( fnOver, fnOut ) {
9001		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
9002	}
9003} );
9004
9005
9006var location = window.location;
9007
9008var nonce = jQuery.now();
9009
9010var rquery = ( /\?/ );
9011
9012
9013
9014var rvalidtokens = /(,)|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/g;
9015
9016jQuery.parseJSON = function( data ) {
9017
9018	// Attempt to parse using the native JSON parser first
9019	if ( window.JSON && window.JSON.parse ) {
9020
9021		// Support: Android 2.3
9022		// Workaround failure to string-cast null input
9023		return window.JSON.parse( data + "" );
9024	}
9025
9026	var requireNonComma,
9027		depth = null,
9028		str = jQuery.trim( data + "" );
9029
9030	// Guard against invalid (and possibly dangerous) input by ensuring that nothing remains
9031	// after removing valid tokens
9032	return str && !jQuery.trim( str.replace( rvalidtokens, function( token, comma, open, close ) {
9033
9034		// Force termination if we see a misplaced comma
9035		if ( requireNonComma && comma ) {
9036			depth = 0;
9037		}
9038
9039		// Perform no more replacements after returning to outermost depth
9040		if ( depth === 0 ) {
9041			return token;
9042		}
9043
9044		// Commas must not follow "[", "{", or ","
9045		requireNonComma = open || comma;
9046
9047		// Determine new depth
9048		// array/object open ("[" or "{"): depth += true - false (increment)
9049		// array/object close ("]" or "}"): depth += false - true (decrement)
9050		// other cases ("," or primitive): depth += true - true (numeric cast)
9051		depth += !close - !open;
9052
9053		// Remove this token
9054		return "";
9055	} ) ) ?
9056		( Function( "return " + str ) )() :
9057		jQuery.error( "Invalid JSON: " + data );
9058};
9059
9060
9061// Cross-browser xml parsing
9062jQuery.parseXML = function( data ) {
9063	var xml, tmp;
9064	if ( !data || typeof data !== "string" ) {
9065		return null;
9066	}
9067	try {
9068		if ( window.DOMParser ) { // Standard
9069			tmp = new window.DOMParser();
9070			xml = tmp.parseFromString( data, "text/xml" );
9071		} else { // IE
9072			xml = new window.ActiveXObject( "Microsoft.XMLDOM" );
9073			xml.async = "false";
9074			xml.loadXML( data );
9075		}
9076	} catch ( e ) {
9077		xml = undefined;
9078	}
9079	if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
9080		jQuery.error( "Invalid XML: " + data );
9081	}
9082	return xml;
9083};
9084
9085
9086var
9087	rhash = /#.*$/,
9088	rts = /([?&])_=[^&]*/,
9089
9090	// IE leaves an \r character at EOL
9091	rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg,
9092
9093	// #7653, #8125, #8152: local protocol detection
9094	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
9095	rnoContent = /^(?:GET|HEAD)$/,
9096	rprotocol = /^\/\//,
9097	rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,
9098
9099	/* Prefilters
9100	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
9101	 * 2) These are called:
9102	 *    - BEFORE asking for a transport
9103	 *    - AFTER param serialization (s.data is a string if s.processData is true)
9104	 * 3) key is the dataType
9105	 * 4) the catchall symbol "*" can be used
9106	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
9107	 */
9108	prefilters = {},
9109
9110	/* Transports bindings
9111	 * 1) key is the dataType
9112	 * 2) the catchall symbol "*" can be used
9113	 * 3) selection will start with transport dataType and THEN go to "*" if needed
9114	 */
9115	transports = {},
9116
9117	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
9118	allTypes = "*/".concat( "*" ),
9119
9120	// Document location
9121	ajaxLocation = location.href,
9122
9123	// Segment location into parts
9124	ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
9125
9126// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
9127function addToPrefiltersOrTransports( structure ) {
9128
9129	// dataTypeExpression is optional and defaults to "*"
9130	return function( dataTypeExpression, func ) {
9131
9132		if ( typeof dataTypeExpression !== "string" ) {
9133			func = dataTypeExpression;
9134			dataTypeExpression = "*";
9135		}
9136
9137		var dataType,
9138			i = 0,
9139			dataTypes = dataTypeExpression.toLowerCase().match( rnotwhite ) || [];
9140
9141		if ( jQuery.isFunction( func ) ) {
9142
9143			// For each dataType in the dataTypeExpression
9144			while ( ( dataType = dataTypes[ i++ ] ) ) {
9145
9146				// Prepend if requested
9147				if ( dataType.charAt( 0 ) === "+" ) {
9148					dataType = dataType.slice( 1 ) || "*";
9149					( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
9150
9151				// Otherwise append
9152				} else {
9153					( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
9154				}
9155			}
9156		}
9157	};
9158}
9159
9160// Base inspection function for prefilters and transports
9161function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
9162
9163	var inspected = {},
9164		seekingTransport = ( structure === transports );
9165
9166	function inspect( dataType ) {
9167		var selected;
9168		inspected[ dataType ] = true;
9169		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
9170			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
9171			if ( typeof dataTypeOrTransport === "string" &&
9172				!seekingTransport && !inspected[ dataTypeOrTransport ] ) {
9173
9174				options.dataTypes.unshift( dataTypeOrTransport );
9175				inspect( dataTypeOrTransport );
9176				return false;
9177			} else if ( seekingTransport ) {
9178				return !( selected = dataTypeOrTransport );
9179			}
9180		} );
9181		return selected;
9182	}
9183
9184	return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
9185}
9186
9187// A special extend for ajax options
9188// that takes "flat" options (not to be deep extended)
9189// Fixes #9887
9190function ajaxExtend( target, src ) {
9191	var deep, key,
9192		flatOptions = jQuery.ajaxSettings.flatOptions || {};
9193
9194	for ( key in src ) {
9195		if ( src[ key ] !== undefined ) {
9196			( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
9197		}
9198	}
9199	if ( deep ) {
9200		jQuery.extend( true, target, deep );
9201	}
9202
9203	return target;
9204}
9205
9206/* Handles responses to an ajax request:
9207 * - finds the right dataType (mediates between content-type and expected dataType)
9208 * - returns the corresponding response
9209 */
9210function ajaxHandleResponses( s, jqXHR, responses ) {
9211	var firstDataType, ct, finalDataType, type,
9212		contents = s.contents,
9213		dataTypes = s.dataTypes;
9214
9215	// Remove auto dataType and get content-type in the process
9216	while ( dataTypes[ 0 ] === "*" ) {
9217		dataTypes.shift();
9218		if ( ct === undefined ) {
9219			ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
9220		}
9221	}
9222
9223	// Check if we're dealing with a known content-type
9224	if ( ct ) {
9225		for ( type in contents ) {
9226			if ( contents[ type ] && contents[ type ].test( ct ) ) {
9227				dataTypes.unshift( type );
9228				break;
9229			}
9230		}
9231	}
9232
9233	// Check to see if we have a response for the expected dataType
9234	if ( dataTypes[ 0 ] in responses ) {
9235		finalDataType = dataTypes[ 0 ];
9236	} else {
9237
9238		// Try convertible dataTypes
9239		for ( type in responses ) {
9240			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
9241				finalDataType = type;
9242				break;
9243			}
9244			if ( !firstDataType ) {
9245				firstDataType = type;
9246			}
9247		}
9248
9249		// Or just use first one
9250		finalDataType = finalDataType || firstDataType;
9251	}
9252
9253	// If we found a dataType
9254	// We add the dataType to the list if needed
9255	// and return the corresponding response
9256	if ( finalDataType ) {
9257		if ( finalDataType !== dataTypes[ 0 ] ) {
9258			dataTypes.unshift( finalDataType );
9259		}
9260		return responses[ finalDataType ];
9261	}
9262}
9263
9264/* Chain conversions given the request and the original response
9265 * Also sets the responseXXX fields on the jqXHR instance
9266 */
9267function ajaxConvert( s, response, jqXHR, isSuccess ) {
9268	var conv2, current, conv, tmp, prev,
9269		converters = {},
9270
9271		// Work with a copy of dataTypes in case we need to modify it for conversion
9272		dataTypes = s.dataTypes.slice();
9273
9274	// Create converters map with lowercased keys
9275	if ( dataTypes[ 1 ] ) {
9276		for ( conv in s.converters ) {
9277			converters[ conv.toLowerCase() ] = s.converters[ conv ];
9278		}
9279	}
9280
9281	current = dataTypes.shift();
9282
9283	// Convert to each sequential dataType
9284	while ( current ) {
9285
9286		if ( s.responseFields[ current ] ) {
9287			jqXHR[ s.responseFields[ current ] ] = response;
9288		}
9289
9290		// Apply the dataFilter if provided
9291		if ( !prev && isSuccess && s.dataFilter ) {
9292			response = s.dataFilter( response, s.dataType );
9293		}
9294
9295		prev = current;
9296		current = dataTypes.shift();
9297
9298		if ( current ) {
9299
9300			// There's only work to do if current dataType is non-auto
9301			if ( current === "*" ) {
9302
9303				current = prev;
9304
9305			// Convert response if prev dataType is non-auto and differs from current
9306			} else if ( prev !== "*" && prev !== current ) {
9307
9308				// Seek a direct converter
9309				conv = converters[ prev + " " + current ] || converters[ "* " + current ];
9310
9311				// If none found, seek a pair
9312				if ( !conv ) {
9313					for ( conv2 in converters ) {
9314
9315						// If conv2 outputs current
9316						tmp = conv2.split( " " );
9317						if ( tmp[ 1 ] === current ) {
9318
9319							// If prev can be converted to accepted input
9320							conv = converters[ prev + " " + tmp[ 0 ] ] ||
9321								converters[ "* " + tmp[ 0 ] ];
9322							if ( conv ) {
9323
9324								// Condense equivalence converters
9325								if ( conv === true ) {
9326									conv = converters[ conv2 ];
9327
9328								// Otherwise, insert the intermediate dataType
9329								} else if ( converters[ conv2 ] !== true ) {
9330									current = tmp[ 0 ];
9331									dataTypes.unshift( tmp[ 1 ] );
9332								}
9333								break;
9334							}
9335						}
9336					}
9337				}
9338
9339				// Apply converter (if not an equivalence)
9340				if ( conv !== true ) {
9341
9342					// Unless errors are allowed to bubble, catch and return them
9343					if ( conv && s[ "throws" ] ) { // jscs:ignore requireDotNotation
9344						response = conv( response );
9345					} else {
9346						try {
9347							response = conv( response );
9348						} catch ( e ) {
9349							return {
9350								state: "parsererror",
9351								error: conv ? e : "No conversion from " + prev + " to " + current
9352							};
9353						}
9354					}
9355				}
9356			}
9357		}
9358	}
9359
9360	return { state: "success", data: response };
9361}
9362
9363jQuery.extend( {
9364
9365	// Counter for holding the number of active queries
9366	active: 0,
9367
9368	// Last-Modified header cache for next request
9369	lastModified: {},
9370	etag: {},
9371
9372	ajaxSettings: {
9373		url: ajaxLocation,
9374		type: "GET",
9375		isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
9376		global: true,
9377		processData: true,
9378		async: true,
9379		contentType: "application/x-www-form-urlencoded; charset=UTF-8",
9380		/*
9381		timeout: 0,
9382		data: null,
9383		dataType: null,
9384		username: null,
9385		password: null,
9386		cache: null,
9387		throws: false,
9388		traditional: false,
9389		headers: {},
9390		*/
9391
9392		accepts: {
9393			"*": allTypes,
9394			text: "text/plain",
9395			html: "text/html",
9396			xml: "application/xml, text/xml",
9397			json: "application/json, text/javascript"
9398		},
9399
9400		contents: {
9401			xml: /\bxml\b/,
9402			html: /\bhtml/,
9403			json: /\bjson\b/
9404		},
9405
9406		responseFields: {
9407			xml: "responseXML",
9408			text: "responseText",
9409			json: "responseJSON"
9410		},
9411
9412		// Data converters
9413		// Keys separate source (or catchall "*") and destination types with a single space
9414		converters: {
9415
9416			// Convert anything to text
9417			"* text": String,
9418
9419			// Text to html (true = no transformation)
9420			"text html": true,
9421
9422			// Evaluate text as a json expression
9423			"text json": jQuery.parseJSON,
9424
9425			// Parse text as xml
9426			"text xml": jQuery.parseXML
9427		},
9428
9429		// For options that shouldn't be deep extended:
9430		// you can add your own custom options here if
9431		// and when you create one that shouldn't be
9432		// deep extended (see ajaxExtend)
9433		flatOptions: {
9434			url: true,
9435			context: true
9436		}
9437	},
9438
9439	// Creates a full fledged settings object into target
9440	// with both ajaxSettings and settings fields.
9441	// If target is omitted, writes into ajaxSettings.
9442	ajaxSetup: function( target, settings ) {
9443		return settings ?
9444
9445			// Building a settings object
9446			ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
9447
9448			// Extending ajaxSettings
9449			ajaxExtend( jQuery.ajaxSettings, target );
9450	},
9451
9452	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
9453	ajaxTransport: addToPrefiltersOrTransports( transports ),
9454
9455	// Main method
9456	ajax: function( url, options ) {
9457
9458		// If url is an object, simulate pre-1.5 signature
9459		if ( typeof url === "object" ) {
9460			options = url;
9461			url = undefined;
9462		}
9463
9464		// Force options to be an object
9465		options = options || {};
9466
9467		var
9468
9469			// Cross-domain detection vars
9470			parts,
9471
9472			// Loop variable
9473			i,
9474
9475			// URL without anti-cache param
9476			cacheURL,
9477
9478			// Response headers as string
9479			responseHeadersString,
9480
9481			// timeout handle
9482			timeoutTimer,
9483
9484			// To know if global events are to be dispatched
9485			fireGlobals,
9486
9487			transport,
9488
9489			// Response headers
9490			responseHeaders,
9491
9492			// Create the final options object
9493			s = jQuery.ajaxSetup( {}, options ),
9494
9495			// Callbacks context
9496			callbackContext = s.context || s,
9497
9498			// Context for global events is callbackContext if it is a DOM node or jQuery collection
9499			globalEventContext = s.context &&
9500				( callbackContext.nodeType || callbackContext.jquery ) ?
9501					jQuery( callbackContext ) :
9502					jQuery.event,
9503
9504			// Deferreds
9505			deferred = jQuery.Deferred(),
9506			completeDeferred = jQuery.Callbacks( "once memory" ),
9507
9508			// Status-dependent callbacks
9509			statusCode = s.statusCode || {},
9510
9511			// Headers (they are sent all at once)
9512			requestHeaders = {},
9513			requestHeadersNames = {},
9514
9515			// The jqXHR state
9516			state = 0,
9517
9518			// Default abort message
9519			strAbort = "canceled",
9520
9521			// Fake xhr
9522			jqXHR = {
9523				readyState: 0,
9524
9525				// Builds headers hashtable if needed
9526				getResponseHeader: function( key ) {
9527					var match;
9528					if ( state === 2 ) {
9529						if ( !responseHeaders ) {
9530							responseHeaders = {};
9531							while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
9532								responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
9533							}
9534						}
9535						match = responseHeaders[ key.toLowerCase() ];
9536					}
9537					return match == null ? null : match;
9538				},
9539
9540				// Raw string
9541				getAllResponseHeaders: function() {
9542					return state === 2 ? responseHeadersString : null;
9543				},
9544
9545				// Caches the header
9546				setRequestHeader: function( name, value ) {
9547					var lname = name.toLowerCase();
9548					if ( !state ) {
9549						name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
9550						requestHeaders[ name ] = value;
9551					}
9552					return this;
9553				},
9554
9555				// Overrides response content-type header
9556				overrideMimeType: function( type ) {
9557					if ( !state ) {
9558						s.mimeType = type;
9559					}
9560					return this;
9561				},
9562
9563				// Status-dependent callbacks
9564				statusCode: function( map ) {
9565					var code;
9566					if ( map ) {
9567						if ( state < 2 ) {
9568							for ( code in map ) {
9569
9570								// Lazy-add the new callback in a way that preserves old ones
9571								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
9572							}
9573						} else {
9574
9575							// Execute the appropriate callbacks
9576							jqXHR.always( map[ jqXHR.status ] );
9577						}
9578					}
9579					return this;
9580				},
9581
9582				// Cancel the request
9583				abort: function( statusText ) {
9584					var finalText = statusText || strAbort;
9585					if ( transport ) {
9586						transport.abort( finalText );
9587					}
9588					done( 0, finalText );
9589					return this;
9590				}
9591			};
9592
9593		// Attach deferreds
9594		deferred.promise( jqXHR ).complete = completeDeferred.add;
9595		jqXHR.success = jqXHR.done;
9596		jqXHR.error = jqXHR.fail;
9597
9598		// Remove hash character (#7531: and string promotion)
9599		// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
9600		// Handle falsy url in the settings object (#10093: consistency with old signature)
9601		// We also use the url parameter if available
9602		s.url = ( ( url || s.url || ajaxLocation ) + "" )
9603			.replace( rhash, "" )
9604			.replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
9605
9606		// Alias method option to type as per ticket #12004
9607		s.type = options.method || options.type || s.method || s.type;
9608
9609		// Extract dataTypes list
9610		s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( rnotwhite ) || [ "" ];
9611
9612		// A cross-domain request is in order when we have a protocol:host:port mismatch
9613		if ( s.crossDomain == null ) {
9614			parts = rurl.exec( s.url.toLowerCase() );
9615			s.crossDomain = !!( parts &&
9616				( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
9617					( parts[ 3 ] || ( parts[ 1 ] === "http:" ? "80" : "443" ) ) !==
9618						( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? "80" : "443" ) ) )
9619			);
9620		}
9621
9622		// Convert data if not already a string
9623		if ( s.data && s.processData && typeof s.data !== "string" ) {
9624			s.data = jQuery.param( s.data, s.traditional );
9625		}
9626
9627		// Apply prefilters
9628		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
9629
9630		// If request was aborted inside a prefilter, stop there
9631		if ( state === 2 ) {
9632			return jqXHR;
9633		}
9634
9635		// We can fire global events as of now if asked to
9636		// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
9637		fireGlobals = jQuery.event && s.global;
9638
9639		// Watch for a new set of requests
9640		if ( fireGlobals && jQuery.active++ === 0 ) {
9641			jQuery.event.trigger( "ajaxStart" );
9642		}
9643
9644		// Uppercase the type
9645		s.type = s.type.toUpperCase();
9646
9647		// Determine if request has content
9648		s.hasContent = !rnoContent.test( s.type );
9649
9650		// Save the URL in case we're toying with the If-Modified-Since
9651		// and/or If-None-Match header later on
9652		cacheURL = s.url;
9653
9654		// More options handling for requests with no content
9655		if ( !s.hasContent ) {
9656
9657			// If data is available, append data to url
9658			if ( s.data ) {
9659				cacheURL = ( s.url += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data );
9660
9661				// #9682: remove data so that it's not used in an eventual retry
9662				delete s.data;
9663			}
9664
9665			// Add anti-cache in url if needed
9666			if ( s.cache === false ) {
9667				s.url = rts.test( cacheURL ) ?
9668
9669					// If there is already a '_' parameter, set its value
9670					cacheURL.replace( rts, "$1_=" + nonce++ ) :
9671
9672					// Otherwise add one to the end
9673					cacheURL + ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + nonce++;
9674			}
9675		}
9676
9677		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
9678		if ( s.ifModified ) {
9679			if ( jQuery.lastModified[ cacheURL ] ) {
9680				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
9681			}
9682			if ( jQuery.etag[ cacheURL ] ) {
9683				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
9684			}
9685		}
9686
9687		// Set the correct header, if data is being sent
9688		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
9689			jqXHR.setRequestHeader( "Content-Type", s.contentType );
9690		}
9691
9692		// Set the Accepts header for the server, depending on the dataType
9693		jqXHR.setRequestHeader(
9694			"Accept",
9695			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
9696				s.accepts[ s.dataTypes[ 0 ] ] +
9697					( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
9698				s.accepts[ "*" ]
9699		);
9700
9701		// Check for headers option
9702		for ( i in s.headers ) {
9703			jqXHR.setRequestHeader( i, s.headers[ i ] );
9704		}
9705
9706		// Allow custom headers/mimetypes and early abort
9707		if ( s.beforeSend &&
9708			( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
9709
9710			// Abort if not done already and return
9711			return jqXHR.abort();
9712		}
9713
9714		// aborting is no longer a cancellation
9715		strAbort = "abort";
9716
9717		// Install callbacks on deferreds
9718		for ( i in { success: 1, error: 1, complete: 1 } ) {
9719			jqXHR[ i ]( s[ i ] );
9720		}
9721
9722		// Get transport
9723		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
9724
9725		// If no transport, we auto-abort
9726		if ( !transport ) {
9727			done( -1, "No Transport" );
9728		} else {
9729			jqXHR.readyState = 1;
9730
9731			// Send global event
9732			if ( fireGlobals ) {
9733				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
9734			}
9735
9736			// If request was aborted inside ajaxSend, stop there
9737			if ( state === 2 ) {
9738				return jqXHR;
9739			}
9740
9741			// Timeout
9742			if ( s.async && s.timeout > 0 ) {
9743				timeoutTimer = window.setTimeout( function() {
9744					jqXHR.abort( "timeout" );
9745				}, s.timeout );
9746			}
9747
9748			try {
9749				state = 1;
9750				transport.send( requestHeaders, done );
9751			} catch ( e ) {
9752
9753				// Propagate exception as error if not done
9754				if ( state < 2 ) {
9755					done( -1, e );
9756
9757				// Simply rethrow otherwise
9758				} else {
9759					throw e;
9760				}
9761			}
9762		}
9763
9764		// Callback for when everything is done
9765		function done( status, nativeStatusText, responses, headers ) {
9766			var isSuccess, success, error, response, modified,
9767				statusText = nativeStatusText;
9768
9769			// Called once
9770			if ( state === 2 ) {
9771				return;
9772			}
9773
9774			// State is "done" now
9775			state = 2;
9776
9777			// Clear timeout if it exists
9778			if ( timeoutTimer ) {
9779				window.clearTimeout( timeoutTimer );
9780			}
9781
9782			// Dereference transport for early garbage collection
9783			// (no matter how long the jqXHR object will be used)
9784			transport = undefined;
9785
9786			// Cache response headers
9787			responseHeadersString = headers || "";
9788
9789			// Set readyState
9790			jqXHR.readyState = status > 0 ? 4 : 0;
9791
9792			// Determine if successful
9793			isSuccess = status >= 200 && status < 300 || status === 304;
9794
9795			// Get response data
9796			if ( responses ) {
9797				response = ajaxHandleResponses( s, jqXHR, responses );
9798			}
9799
9800			// Convert no matter what (that way responseXXX fields are always set)
9801			response = ajaxConvert( s, response, jqXHR, isSuccess );
9802
9803			// If successful, handle type chaining
9804			if ( isSuccess ) {
9805
9806				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
9807				if ( s.ifModified ) {
9808					modified = jqXHR.getResponseHeader( "Last-Modified" );
9809					if ( modified ) {
9810						jQuery.lastModified[ cacheURL ] = modified;
9811					}
9812					modified = jqXHR.getResponseHeader( "etag" );
9813					if ( modified ) {
9814						jQuery.etag[ cacheURL ] = modified;
9815					}
9816				}
9817
9818				// if no content
9819				if ( status === 204 || s.type === "HEAD" ) {
9820					statusText = "nocontent";
9821
9822				// if not modified
9823				} else if ( status === 304 ) {
9824					statusText = "notmodified";
9825
9826				// If we have data, let's convert it
9827				} else {
9828					statusText = response.state;
9829					success = response.data;
9830					error = response.error;
9831					isSuccess = !error;
9832				}
9833			} else {
9834
9835				// We extract error from statusText
9836				// then normalize statusText and status for non-aborts
9837				error = statusText;
9838				if ( status || !statusText ) {
9839					statusText = "error";
9840					if ( status < 0 ) {
9841						status = 0;
9842					}
9843				}
9844			}
9845
9846			// Set data for the fake xhr object
9847			jqXHR.status = status;
9848			jqXHR.statusText = ( nativeStatusText || statusText ) + "";
9849
9850			// Success/Error
9851			if ( isSuccess ) {
9852				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
9853			} else {
9854				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
9855			}
9856
9857			// Status-dependent callbacks
9858			jqXHR.statusCode( statusCode );
9859			statusCode = undefined;
9860
9861			if ( fireGlobals ) {
9862				globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
9863					[ jqXHR, s, isSuccess ? success : error ] );
9864			}
9865
9866			// Complete
9867			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
9868
9869			if ( fireGlobals ) {
9870				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
9871
9872				// Handle the global AJAX counter
9873				if ( !( --jQuery.active ) ) {
9874					jQuery.event.trigger( "ajaxStop" );
9875				}
9876			}
9877		}
9878
9879		return jqXHR;
9880	},
9881
9882	getJSON: function( url, data, callback ) {
9883		return jQuery.get( url, data, callback, "json" );
9884	},
9885
9886	getScript: function( url, callback ) {
9887		return jQuery.get( url, undefined, callback, "script" );
9888	}
9889} );
9890
9891jQuery.each( [ "get", "post" ], function( i, method ) {
9892	jQuery[ method ] = function( url, data, callback, type ) {
9893
9894		// shift arguments if data argument was omitted
9895		if ( jQuery.isFunction( data ) ) {
9896			type = type || callback;
9897			callback = data;
9898			data = undefined;
9899		}
9900
9901		// The url can be an options object (which then must have .url)
9902		return jQuery.ajax( jQuery.extend( {
9903			url: url,
9904			type: method,
9905			dataType: type,
9906			data: data,
9907			success: callback
9908		}, jQuery.isPlainObject( url ) && url ) );
9909	};
9910} );
9911
9912
9913jQuery._evalUrl = function( url ) {
9914	return jQuery.ajax( {
9915		url: url,
9916
9917		// Make this explicit, since user can override this through ajaxSetup (#11264)
9918		type: "GET",
9919		dataType: "script",
9920		cache: true,
9921		async: false,
9922		global: false,
9923		"throws": true
9924	} );
9925};
9926
9927
9928jQuery.fn.extend( {
9929	wrapAll: function( html ) {
9930		if ( jQuery.isFunction( html ) ) {
9931			return this.each( function( i ) {
9932				jQuery( this ).wrapAll( html.call( this, i ) );
9933			} );
9934		}
9935
9936		if ( this[ 0 ] ) {
9937
9938			// The elements to wrap the target around
9939			var wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
9940
9941			if ( this[ 0 ].parentNode ) {
9942				wrap.insertBefore( this[ 0 ] );
9943			}
9944
9945			wrap.map( function() {
9946				var elem = this;
9947
9948				while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
9949					elem = elem.firstChild;
9950				}
9951
9952				return elem;
9953			} ).append( this );
9954		}
9955
9956		return this;
9957	},
9958
9959	wrapInner: function( html ) {
9960		if ( jQuery.isFunction( html ) ) {
9961			return this.each( function( i ) {
9962				jQuery( this ).wrapInner( html.call( this, i ) );
9963			} );
9964		}
9965
9966		return this.each( function() {
9967			var self = jQuery( this ),
9968				contents = self.contents();
9969
9970			if ( contents.length ) {
9971				contents.wrapAll( html );
9972
9973			} else {
9974				self.append( html );
9975			}
9976		} );
9977	},
9978
9979	wrap: function( html ) {
9980		var isFunction = jQuery.isFunction( html );
9981
9982		return this.each( function( i ) {
9983			jQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html );
9984		} );
9985	},
9986
9987	unwrap: function() {
9988		return this.parent().each( function() {
9989			if ( !jQuery.nodeName( this, "body" ) ) {
9990				jQuery( this ).replaceWith( this.childNodes );
9991			}
9992		} ).end();
9993	}
9994} );
9995
9996
9997function getDisplay( elem ) {
9998	return elem.style && elem.style.display || jQuery.css( elem, "display" );
9999}
10000
10001function filterHidden( elem ) {
10002	while ( elem && elem.nodeType === 1 ) {
10003		if ( getDisplay( elem ) === "none" || elem.type === "hidden" ) {
10004			return true;
10005		}
10006		elem = elem.parentNode;
10007	}
10008	return false;
10009}
10010
10011jQuery.expr.filters.hidden = function( elem ) {
10012
10013	// Support: Opera <= 12.12
10014	// Opera reports offsetWidths and offsetHeights less than zero on some elements
10015	return support.reliableHiddenOffsets() ?
10016		( elem.offsetWidth <= 0 && elem.offsetHeight <= 0 &&
10017			!elem.getClientRects().length ) :
10018			filterHidden( elem );
10019};
10020
10021jQuery.expr.filters.visible = function( elem ) {
10022	return !jQuery.expr.filters.hidden( elem );
10023};
10024
10025
10026
10027
10028var r20 = /%20/g,
10029	rbracket = /\[\]$/,
10030	rCRLF = /\r?\n/g,
10031	rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
10032	rsubmittable = /^(?:input|select|textarea|keygen)/i;
10033
10034function buildParams( prefix, obj, traditional, add ) {
10035	var name;
10036
10037	if ( jQuery.isArray( obj ) ) {
10038
10039		// Serialize array item.
10040		jQuery.each( obj, function( i, v ) {
10041			if ( traditional || rbracket.test( prefix ) ) {
10042
10043				// Treat each array item as a scalar.
10044				add( prefix, v );
10045
10046			} else {
10047
10048				// Item is non-scalar (array or object), encode its numeric index.
10049				buildParams(
10050					prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
10051					v,
10052					traditional,
10053					add
10054				);
10055			}
10056		} );
10057
10058	} else if ( !traditional && jQuery.type( obj ) === "object" ) {
10059
10060		// Serialize object item.
10061		for ( name in obj ) {
10062			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
10063		}
10064
10065	} else {
10066
10067		// Serialize scalar item.
10068		add( prefix, obj );
10069	}
10070}
10071
10072// Serialize an array of form elements or a set of
10073// key/values into a query string
10074jQuery.param = function( a, traditional ) {
10075	var prefix,
10076		s = [],
10077		add = function( key, value ) {
10078
10079			// If value is a function, invoke it and return its value
10080			value = jQuery.isFunction( value ) ? value() : ( value == null ? "" : value );
10081			s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
10082		};
10083
10084	// Set traditional to true for jQuery <= 1.3.2 behavior.
10085	if ( traditional === undefined ) {
10086		traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
10087	}
10088
10089	// If an array was passed in, assume that it is an array of form elements.
10090	if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
10091
10092		// Serialize the form elements
10093		jQuery.each( a, function() {
10094			add( this.name, this.value );
10095		} );
10096
10097	} else {
10098
10099		// If traditional, encode the "old" way (the way 1.3.2 or older
10100		// did it), otherwise encode params recursively.
10101		for ( prefix in a ) {
10102			buildParams( prefix, a[ prefix ], traditional, add );
10103		}
10104	}
10105
10106	// Return the resulting serialization
10107	return s.join( "&" ).replace( r20, "+" );
10108};
10109
10110jQuery.fn.extend( {
10111	serialize: function() {
10112		return jQuery.param( this.serializeArray() );
10113	},
10114	serializeArray: function() {
10115		return this.map( function() {
10116
10117			// Can add propHook for "elements" to filter or add form elements
10118			var elements = jQuery.prop( this, "elements" );
10119			return elements ? jQuery.makeArray( elements ) : this;
10120		} )
10121		.filter( function() {
10122			var type = this.type;
10123
10124			// Use .is(":disabled") so that fieldset[disabled] works
10125			return this.name && !jQuery( this ).is( ":disabled" ) &&
10126				rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
10127				( this.checked || !rcheckableType.test( type ) );
10128		} )
10129		.map( function( i, elem ) {
10130			var val = jQuery( this ).val();
10131
10132			return val == null ?
10133				null :
10134				jQuery.isArray( val ) ?
10135					jQuery.map( val, function( val ) {
10136						return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
10137					} ) :
10138					{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
10139		} ).get();
10140	}
10141} );
10142
10143
10144// Create the request object
10145// (This is still attached to ajaxSettings for backward compatibility)
10146jQuery.ajaxSettings.xhr = window.ActiveXObject !== undefined ?
10147
10148	// Support: IE6-IE8
10149	function() {
10150
10151		// XHR cannot access local files, always use ActiveX for that case
10152		if ( this.isLocal ) {
10153			return createActiveXHR();
10154		}
10155
10156		// Support: IE 9-11
10157		// IE seems to error on cross-domain PATCH requests when ActiveX XHR
10158		// is used. In IE 9+ always use the native XHR.
10159		// Note: this condition won't catch Edge as it doesn't define
10160		// document.documentMode but it also doesn't support ActiveX so it won't
10161		// reach this code.
10162		if ( document.documentMode > 8 ) {
10163			return createStandardXHR();
10164		}
10165
10166		// Support: IE<9
10167		// oldIE XHR does not support non-RFC2616 methods (#13240)
10168		// See http://msdn.microsoft.com/en-us/library/ie/ms536648(v=vs.85).aspx
10169		// and http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9
10170		// Although this check for six methods instead of eight
10171		// since IE also does not support "trace" and "connect"
10172		return /^(get|post|head|put|delete|options)$/i.test( this.type ) &&
10173			createStandardXHR() || createActiveXHR();
10174	} :
10175
10176	// For all other browsers, use the standard XMLHttpRequest object
10177	createStandardXHR;
10178
10179var xhrId = 0,
10180	xhrCallbacks = {},
10181	xhrSupported = jQuery.ajaxSettings.xhr();
10182
10183// Support: IE<10
10184// Open requests must be manually aborted on unload (#5280)
10185// See https://support.microsoft.com/kb/2856746 for more info
10186if ( window.attachEvent ) {
10187	window.attachEvent( "onunload", function() {
10188		for ( var key in xhrCallbacks ) {
10189			xhrCallbacks[ key ]( undefined, true );
10190		}
10191	} );
10192}
10193
10194// Determine support properties
10195support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
10196xhrSupported = support.ajax = !!xhrSupported;
10197
10198// Create transport if the browser can provide an xhr
10199if ( xhrSupported ) {
10200
10201	jQuery.ajaxTransport( function( options ) {
10202
10203		// Cross domain only allowed if supported through XMLHttpRequest
10204		if ( !options.crossDomain || support.cors ) {
10205
10206			var callback;
10207
10208			return {
10209				send: function( headers, complete ) {
10210					var i,
10211						xhr = options.xhr(),
10212						id = ++xhrId;
10213
10214					// Open the socket
10215					xhr.open(
10216						options.type,
10217						options.url,
10218						options.async,
10219						options.username,
10220						options.password
10221					);
10222
10223					// Apply custom fields if provided
10224					if ( options.xhrFields ) {
10225						for ( i in options.xhrFields ) {
10226							xhr[ i ] = options.xhrFields[ i ];
10227						}
10228					}
10229
10230					// Override mime type if needed
10231					if ( options.mimeType && xhr.overrideMimeType ) {
10232						xhr.overrideMimeType( options.mimeType );
10233					}
10234
10235					// X-Requested-With header
10236					// For cross-domain requests, seeing as conditions for a preflight are
10237					// akin to a jigsaw puzzle, we simply never set it to be sure.
10238					// (it can always be set on a per-request basis or even using ajaxSetup)
10239					// For same-domain requests, won't change header if already provided.
10240					if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
10241						headers[ "X-Requested-With" ] = "XMLHttpRequest";
10242					}
10243
10244					// Set headers
10245					for ( i in headers ) {
10246
10247						// Support: IE<9
10248						// IE's ActiveXObject throws a 'Type Mismatch' exception when setting
10249						// request header to a null-value.
10250						//
10251						// To keep consistent with other XHR implementations, cast the value
10252						// to string and ignore `undefined`.
10253						if ( headers[ i ] !== undefined ) {
10254							xhr.setRequestHeader( i, headers[ i ] + "" );
10255						}
10256					}
10257
10258					// Do send the request
10259					// This may raise an exception which is actually
10260					// handled in jQuery.ajax (so no try/catch here)
10261					xhr.send( ( options.hasContent && options.data ) || null );
10262
10263					// Listener
10264					callback = function( _, isAbort ) {
10265						var status, statusText, responses;
10266
10267						// Was never called and is aborted or complete
10268						if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
10269
10270							// Clean up
10271							delete xhrCallbacks[ id ];
10272							callback = undefined;
10273							xhr.onreadystatechange = jQuery.noop;
10274
10275							// Abort manually if needed
10276							if ( isAbort ) {
10277								if ( xhr.readyState !== 4 ) {
10278									xhr.abort();
10279								}
10280							} else {
10281								responses = {};
10282								status = xhr.status;
10283
10284								// Support: IE<10
10285								// Accessing binary-data responseText throws an exception
10286								// (#11426)
10287								if ( typeof xhr.responseText === "string" ) {
10288									responses.text = xhr.responseText;
10289								}
10290
10291								// Firefox throws an exception when accessing
10292								// statusText for faulty cross-domain requests
10293								try {
10294									statusText = xhr.statusText;
10295								} catch ( e ) {
10296
10297									// We normalize with Webkit giving an empty statusText
10298									statusText = "";
10299								}
10300
10301								// Filter status for non standard behaviors
10302
10303								// If the request is local and we have data: assume a success
10304								// (success with no data won't get notified, that's the best we
10305								// can do given current implementations)
10306								if ( !status && options.isLocal && !options.crossDomain ) {
10307									status = responses.text ? 200 : 404;
10308
10309								// IE - #1450: sometimes returns 1223 when it should be 204
10310								} else if ( status === 1223 ) {
10311									status = 204;
10312								}
10313							}
10314						}
10315
10316						// Call complete if needed
10317						if ( responses ) {
10318							complete( status, statusText, responses, xhr.getAllResponseHeaders() );
10319						}
10320					};
10321
10322					// Do send the request
10323					// `xhr.send` may raise an exception, but it will be
10324					// handled in jQuery.ajax (so no try/catch here)
10325					if ( !options.async ) {
10326
10327						// If we're in sync mode we fire the callback
10328						callback();
10329					} else if ( xhr.readyState === 4 ) {
10330
10331						// (IE6 & IE7) if it's in cache and has been
10332						// retrieved directly we need to fire the callback
10333						window.setTimeout( callback );
10334					} else {
10335
10336						// Register the callback, but delay it in case `xhr.send` throws
10337						// Add to the list of active xhr callbacks
10338						xhr.onreadystatechange = xhrCallbacks[ id ] = callback;
10339					}
10340				},
10341
10342				abort: function() {
10343					if ( callback ) {
10344						callback( undefined, true );
10345					}
10346				}
10347			};
10348		}
10349	} );
10350}
10351
10352// Functions to create xhrs
10353function createStandardXHR() {
10354	try {
10355		return new window.XMLHttpRequest();
10356	} catch ( e ) {}
10357}
10358
10359function createActiveXHR() {
10360	try {
10361		return new window.ActiveXObject( "Microsoft.XMLHTTP" );
10362	} catch ( e ) {}
10363}
10364
10365
10366
10367
10368// Install script dataType
10369jQuery.ajaxSetup( {
10370	accepts: {
10371		script: "text/javascript, application/javascript, " +
10372			"application/ecmascript, application/x-ecmascript"
10373	},
10374	contents: {
10375		script: /\b(?:java|ecma)script\b/
10376	},
10377	converters: {
10378		"text script": function( text ) {
10379			jQuery.globalEval( text );
10380			return text;
10381		}
10382	}
10383} );
10384
10385// Handle cache's special case and global
10386jQuery.ajaxPrefilter( "script", function( s ) {
10387	if ( s.cache === undefined ) {
10388		s.cache = false;
10389	}
10390	if ( s.crossDomain ) {
10391		s.type = "GET";
10392		s.global = false;
10393	}
10394} );
10395
10396// Bind script tag hack transport
10397jQuery.ajaxTransport( "script", function( s ) {
10398
10399	// This transport only deals with cross domain requests
10400	if ( s.crossDomain ) {
10401
10402		var script,
10403			head = document.head || jQuery( "head" )[ 0 ] || document.documentElement;
10404
10405		return {
10406
10407			send: function( _, callback ) {
10408
10409				script = document.createElement( "script" );
10410
10411				script.async = true;
10412
10413				if ( s.scriptCharset ) {
10414					script.charset = s.scriptCharset;
10415				}
10416
10417				script.src = s.url;
10418
10419				// Attach handlers for all browsers
10420				script.onload = script.onreadystatechange = function( _, isAbort ) {
10421
10422					if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
10423
10424						// Handle memory leak in IE
10425						script.onload = script.onreadystatechange = null;
10426
10427						// Remove the script
10428						if ( script.parentNode ) {
10429							script.parentNode.removeChild( script );
10430						}
10431
10432						// Dereference the script
10433						script = null;
10434
10435						// Callback if not abort
10436						if ( !isAbort ) {
10437							callback( 200, "success" );
10438						}
10439					}
10440				};
10441
10442				// Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending
10443				// Use native DOM manipulation to avoid our domManip AJAX trickery
10444				head.insertBefore( script, head.firstChild );
10445			},
10446
10447			abort: function() {
10448				if ( script ) {
10449					script.onload( undefined, true );
10450				}
10451			}
10452		};
10453	}
10454} );
10455
10456
10457
10458
10459var oldCallbacks = [],
10460	rjsonp = /(=)\?(?=&|$)|\?\?/;
10461
10462// Default jsonp settings
10463jQuery.ajaxSetup( {
10464	jsonp: "callback",
10465	jsonpCallback: function() {
10466		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
10467		this[ callback ] = true;
10468		return callback;
10469	}
10470} );
10471
10472// Detect, normalize options and install callbacks for jsonp requests
10473jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
10474
10475	var callbackName, overwritten, responseContainer,
10476		jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
10477			"url" :
10478			typeof s.data === "string" &&
10479				( s.contentType || "" )
10480					.indexOf( "application/x-www-form-urlencoded" ) === 0 &&
10481				rjsonp.test( s.data ) && "data"
10482		);
10483
10484	// Handle iff the expected data type is "jsonp" or we have a parameter to set
10485	if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
10486
10487		// Get callback name, remembering preexisting value associated with it
10488		callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
10489			s.jsonpCallback() :
10490			s.jsonpCallback;
10491
10492		// Insert callback into url or form data
10493		if ( jsonProp ) {
10494			s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
10495		} else if ( s.jsonp !== false ) {
10496			s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
10497		}
10498
10499		// Use data converter to retrieve json after script execution
10500		s.converters[ "script json" ] = function() {
10501			if ( !responseContainer ) {
10502				jQuery.error( callbackName + " was not called" );
10503			}
10504			return responseContainer[ 0 ];
10505		};
10506
10507		// force json dataType
10508		s.dataTypes[ 0 ] = "json";
10509
10510		// Install callback
10511		overwritten = window[ callbackName ];
10512		window[ callbackName ] = function() {
10513			responseContainer = arguments;
10514		};
10515
10516		// Clean-up function (fires after converters)
10517		jqXHR.always( function() {
10518
10519			// If previous value didn't exist - remove it
10520			if ( overwritten === undefined ) {
10521				jQuery( window ).removeProp( callbackName );
10522
10523			// Otherwise restore preexisting value
10524			} else {
10525				window[ callbackName ] = overwritten;
10526			}
10527
10528			// Save back as free
10529			if ( s[ callbackName ] ) {
10530
10531				// make sure that re-using the options doesn't screw things around
10532				s.jsonpCallback = originalSettings.jsonpCallback;
10533
10534				// save the callback name for future use
10535				oldCallbacks.push( callbackName );
10536			}
10537
10538			// Call if it was a function and we have a response
10539			if ( responseContainer && jQuery.isFunction( overwritten ) ) {
10540				overwritten( responseContainer[ 0 ] );
10541			}
10542
10543			responseContainer = overwritten = undefined;
10544		} );
10545
10546		// Delegate to script
10547		return "script";
10548	}
10549} );
10550
10551
10552
10553
10554// data: string of html
10555// context (optional): If specified, the fragment will be created in this context,
10556// defaults to document
10557// keepScripts (optional): If true, will include scripts passed in the html string
10558jQuery.parseHTML = function( data, context, keepScripts ) {
10559	if ( !data || typeof data !== "string" ) {
10560		return null;
10561	}
10562	if ( typeof context === "boolean" ) {
10563		keepScripts = context;
10564		context = false;
10565	}
10566	context = context || document;
10567
10568	var parsed = rsingleTag.exec( data ),
10569		scripts = !keepScripts && [];
10570
10571	// Single tag
10572	if ( parsed ) {
10573		return [ context.createElement( parsed[ 1 ] ) ];
10574	}
10575
10576	parsed = buildFragment( [ data ], context, scripts );
10577
10578	if ( scripts && scripts.length ) {
10579		jQuery( scripts ).remove();
10580	}
10581
10582	return jQuery.merge( [], parsed.childNodes );
10583};
10584
10585
10586// Keep a copy of the old load method
10587var _load = jQuery.fn.load;
10588
10589/**
10590 * Load a url into a page
10591 */
10592jQuery.fn.load = function( url, params, callback ) {
10593	if ( typeof url !== "string" && _load ) {
10594		return _load.apply( this, arguments );
10595	}
10596
10597	var selector, type, response,
10598		self = this,
10599		off = url.indexOf( " " );
10600
10601	if ( off > -1 ) {
10602		selector = jQuery.trim( url.slice( off, url.length ) );
10603		url = url.slice( 0, off );
10604	}
10605
10606	// If it's a function
10607	if ( jQuery.isFunction( params ) ) {
10608
10609		// We assume that it's the callback
10610		callback = params;
10611		params = undefined;
10612
10613	// Otherwise, build a param string
10614	} else if ( params && typeof params === "object" ) {
10615		type = "POST";
10616	}
10617
10618	// If we have elements to modify, make the request
10619	if ( self.length > 0 ) {
10620		jQuery.ajax( {
10621			url: url,
10622
10623			// If "type" variable is undefined, then "GET" method will be used.
10624			// Make value of this field explicit since
10625			// user can override it through ajaxSetup method
10626			type: type || "GET",
10627			dataType: "html",
10628			data: params
10629		} ).done( function( responseText ) {
10630
10631			// Save response for use in complete callback
10632			response = arguments;
10633
10634			self.html( selector ?
10635
10636				// If a selector was specified, locate the right elements in a dummy div
10637				// Exclude scripts to avoid IE 'Permission Denied' errors
10638				jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
10639
10640				// Otherwise use the full result
10641				responseText );
10642
10643		// If the request succeeds, this function gets "data", "status", "jqXHR"
10644		// but they are ignored because response was set above.
10645		// If it fails, this function gets "jqXHR", "status", "error"
10646		} ).always( callback && function( jqXHR, status ) {
10647			self.each( function() {
10648				callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
10649			} );
10650		} );
10651	}
10652
10653	return this;
10654};
10655
10656
10657
10658
10659// Attach a bunch of functions for handling common AJAX events
10660jQuery.each( [
10661	"ajaxStart",
10662	"ajaxStop",
10663	"ajaxComplete",
10664	"ajaxError",
10665	"ajaxSuccess",
10666	"ajaxSend"
10667], function( i, type ) {
10668	jQuery.fn[ type ] = function( fn ) {
10669		return this.on( type, fn );
10670	};
10671} );
10672
10673
10674
10675
10676jQuery.expr.filters.animated = function( elem ) {
10677	return jQuery.grep( jQuery.timers, function( fn ) {
10678		return elem === fn.elem;
10679	} ).length;
10680};
10681
10682
10683
10684
10685
10686/**
10687 * Gets a window from an element
10688 */
10689function getWindow( elem ) {
10690	return jQuery.isWindow( elem ) ?
10691		elem :
10692		elem.nodeType === 9 ?
10693			elem.defaultView || elem.parentWindow :
10694			false;
10695}
10696
10697jQuery.offset = {
10698	setOffset: function( elem, options, i ) {
10699		var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
10700			position = jQuery.css( elem, "position" ),
10701			curElem = jQuery( elem ),
10702			props = {};
10703
10704		// set position first, in-case top/left are set even on static elem
10705		if ( position === "static" ) {
10706			elem.style.position = "relative";
10707		}
10708
10709		curOffset = curElem.offset();
10710		curCSSTop = jQuery.css( elem, "top" );
10711		curCSSLeft = jQuery.css( elem, "left" );
10712		calculatePosition = ( position === "absolute" || position === "fixed" ) &&
10713			jQuery.inArray( "auto", [ curCSSTop, curCSSLeft ] ) > -1;
10714
10715		// need to be able to calculate position if either top or left
10716		// is auto and position is either absolute or fixed
10717		if ( calculatePosition ) {
10718			curPosition = curElem.position();
10719			curTop = curPosition.top;
10720			curLeft = curPosition.left;
10721		} else {
10722			curTop = parseFloat( curCSSTop ) || 0;
10723			curLeft = parseFloat( curCSSLeft ) || 0;
10724		}
10725
10726		if ( jQuery.isFunction( options ) ) {
10727
10728			// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
10729			options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
10730		}
10731
10732		if ( options.top != null ) {
10733			props.top = ( options.top - curOffset.top ) + curTop;
10734		}
10735		if ( options.left != null ) {
10736			props.left = ( options.left - curOffset.left ) + curLeft;
10737		}
10738
10739		if ( "using" in options ) {
10740			options.using.call( elem, props );
10741		} else {
10742			curElem.css( props );
10743		}
10744	}
10745};
10746
10747jQuery.fn.extend( {
10748	offset: function( options ) {
10749		if ( arguments.length ) {
10750			return options === undefined ?
10751				this :
10752				this.each( function( i ) {
10753					jQuery.offset.setOffset( this, options, i );
10754				} );
10755		}
10756
10757		var docElem, win,
10758			box = { top: 0, left: 0 },
10759			elem = this[ 0 ],
10760			doc = elem && elem.ownerDocument;
10761
10762		if ( !doc ) {
10763			return;
10764		}
10765
10766		docElem = doc.documentElement;
10767
10768		// Make sure it's not a disconnected DOM node
10769		if ( !jQuery.contains( docElem, elem ) ) {
10770			return box;
10771		}
10772
10773		// If we don't have gBCR, just use 0,0 rather than error
10774		// BlackBerry 5, iOS 3 (original iPhone)
10775		if ( typeof elem.getBoundingClientRect !== "undefined" ) {
10776			box = elem.getBoundingClientRect();
10777		}
10778		win = getWindow( doc );
10779		return {
10780			top: box.top  + ( win.pageYOffset || docElem.scrollTop )  - ( docElem.clientTop  || 0 ),
10781			left: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 )
10782		};
10783	},
10784
10785	position: function() {
10786		if ( !this[ 0 ] ) {
10787			return;
10788		}
10789
10790		var offsetParent, offset,
10791			parentOffset = { top: 0, left: 0 },
10792			elem = this[ 0 ];
10793
10794		// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
10795		// because it is its only offset parent
10796		if ( jQuery.css( elem, "position" ) === "fixed" ) {
10797
10798			// we assume that getBoundingClientRect is available when computed position is fixed
10799			offset = elem.getBoundingClientRect();
10800		} else {
10801
10802			// Get *real* offsetParent
10803			offsetParent = this.offsetParent();
10804
10805			// Get correct offsets
10806			offset = this.offset();
10807			if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) {
10808				parentOffset = offsetParent.offset();
10809			}
10810
10811			// Add offsetParent borders
10812			parentOffset.top  += jQuery.css( offsetParent[ 0 ], "borderTopWidth", true );
10813			parentOffset.left += jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true );
10814		}
10815
10816		// Subtract parent offsets and element margins
10817		// note: when an element has margin: auto the offsetLeft and marginLeft
10818		// are the same in Safari causing offset.left to incorrectly be 0
10819		return {
10820			top:  offset.top  - parentOffset.top - jQuery.css( elem, "marginTop", true ),
10821			left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
10822		};
10823	},
10824
10825	offsetParent: function() {
10826		return this.map( function() {
10827			var offsetParent = this.offsetParent;
10828
10829			while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) &&
10830				jQuery.css( offsetParent, "position" ) === "static" ) ) {
10831				offsetParent = offsetParent.offsetParent;
10832			}
10833			return offsetParent || documentElement;
10834		} );
10835	}
10836} );
10837
10838// Create scrollLeft and scrollTop methods
10839jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
10840	var top = /Y/.test( prop );
10841
10842	jQuery.fn[ method ] = function( val ) {
10843		return access( this, function( elem, method, val ) {
10844			var win = getWindow( elem );
10845
10846			if ( val === undefined ) {
10847				return win ? ( prop in win ) ? win[ prop ] :
10848					win.document.documentElement[ method ] :
10849					elem[ method ];
10850			}
10851
10852			if ( win ) {
10853				win.scrollTo(
10854					!top ? val : jQuery( win ).scrollLeft(),
10855					top ? val : jQuery( win ).scrollTop()
10856				);
10857
10858			} else {
10859				elem[ method ] = val;
10860			}
10861		}, method, val, arguments.length, null );
10862	};
10863} );
10864
10865// Support: Safari<7-8+, Chrome<37-44+
10866// Add the top/left cssHooks using jQuery.fn.position
10867// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
10868// getComputedStyle returns percent when specified for top/left/bottom/right
10869// rather than make the css module depend on the offset module, we just check for it here
10870jQuery.each( [ "top", "left" ], function( i, prop ) {
10871	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
10872		function( elem, computed ) {
10873			if ( computed ) {
10874				computed = curCSS( elem, prop );
10875
10876				// if curCSS returns percentage, fallback to offset
10877				return rnumnonpx.test( computed ) ?
10878					jQuery( elem ).position()[ prop ] + "px" :
10879					computed;
10880			}
10881		}
10882	);
10883} );
10884
10885
10886// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
10887jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
10888	jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name },
10889	function( defaultExtra, funcName ) {
10890
10891		// margin is only for outerHeight, outerWidth
10892		jQuery.fn[ funcName ] = function( margin, value ) {
10893			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
10894				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
10895
10896			return access( this, function( elem, type, value ) {
10897				var doc;
10898
10899				if ( jQuery.isWindow( elem ) ) {
10900
10901					// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
10902					// isn't a whole lot we can do. See pull request at this URL for discussion:
10903					// https://github.com/jquery/jquery/pull/764
10904					return elem.document.documentElement[ "client" + name ];
10905				}
10906
10907				// Get document width or height
10908				if ( elem.nodeType === 9 ) {
10909					doc = elem.documentElement;
10910
10911					// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
10912					// whichever is greatest
10913					// unfortunately, this causes bug #3838 in IE6/8 only,
10914					// but there is currently no good, small way to fix it.
10915					return Math.max(
10916						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
10917						elem.body[ "offset" + name ], doc[ "offset" + name ],
10918						doc[ "client" + name ]
10919					);
10920				}
10921
10922				return value === undefined ?
10923
10924					// Get width or height on the element, requesting but not forcing parseFloat
10925					jQuery.css( elem, type, extra ) :
10926
10927					// Set width or height on the element
10928					jQuery.style( elem, type, value, extra );
10929			}, type, chainable ? margin : undefined, chainable, null );
10930		};
10931	} );
10932} );
10933
10934
10935jQuery.fn.extend( {
10936
10937	bind: function( types, data, fn ) {
10938		return this.on( types, null, data, fn );
10939	},
10940	unbind: function( types, fn ) {
10941		return this.off( types, null, fn );
10942	},
10943
10944	delegate: function( selector, types, data, fn ) {
10945		return this.on( types, selector, data, fn );
10946	},
10947	undelegate: function( selector, types, fn ) {
10948
10949		// ( namespace ) or ( selector, types [, fn] )
10950		return arguments.length === 1 ?
10951			this.off( selector, "**" ) :
10952			this.off( types, selector || "**", fn );
10953	}
10954} );
10955
10956// The number of elements contained in the matched element set
10957jQuery.fn.size = function() {
10958	return this.length;
10959};
10960
10961jQuery.fn.andSelf = jQuery.fn.addBack;
10962
10963
10964
10965
10966// Register as a named AMD module, since jQuery can be concatenated with other
10967// files that may use define, but not via a proper concatenation script that
10968// understands anonymous AMD modules. A named AMD is safest and most robust
10969// way to register. Lowercase jquery is used because AMD module names are
10970// derived from file names, and jQuery is normally delivered in a lowercase
10971// file name. Do this after creating the global so that if an AMD module wants
10972// to call noConflict to hide this version of jQuery, it will work.
10973
10974// Note that for maximum portability, libraries that are not jQuery should
10975// declare themselves as anonymous modules, and avoid setting a global if an
10976// AMD loader is present. jQuery is a special case. For more information, see
10977// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
10978
10979if ( typeof define === "function" && define.amd ) {
10980	define( "jquery", [], function() {
10981		return jQuery;
10982	} );
10983}
10984
10985
10986
10987var
10988
10989	// Map over jQuery in case of overwrite
10990	_jQuery = window.jQuery,
10991
10992	// Map over the $ in case of overwrite
10993	_$ = window.$;
10994
10995jQuery.noConflict = function( deep ) {
10996	if ( window.$ === jQuery ) {
10997		window.$ = _$;
10998	}
10999
11000	if ( deep && window.jQuery === jQuery ) {
11001		window.jQuery = _jQuery;
11002	}
11003
11004	return jQuery;
11005};
11006
11007// Expose jQuery and $ identifiers, even in
11008// AMD (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
11009// and CommonJS for browser emulators (#13566)
11010if ( !noGlobal ) {
11011	window.jQuery = window.$ = jQuery;
11012}
11013
11014return jQuery;
11015}));