https://carekeralam.com/js/jquery-1.9.1.js

1// JavaScript Document
2/*!
3 * jQuery JavaScript Library v1.9.1
4 * http://jquery.com/
5 *
6 * Includes Sizzle.js
7 * http://sizzlejs.com/
8 *
9 * Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors
10 * Released under the MIT license
11 * http://jquery.org/license
12 *
13 * Date: 2013-2-4
14 */
15(function( window, undefined ) {
16
17// Can't do this because several apps including ASP.NET trace
18// the stack via arguments.caller.callee and Firefox dies if
19// you try to trace through "use strict" call chains. (#13335)
20// Support: Firefox 18+
21//"use strict";
22var
23	// The deferred used on DOM ready
24	readyList,
25
26	// A central reference to the root jQuery(document)
27	rootjQuery,
28
29	// Support: IE<9
30	// For `typeof node.method` instead of `node.method !== undefined`
31	core_strundefined = typeof undefined,
32
33	// Use the correct document accordingly with window argument (sandbox)
34	document = window.document,
35	location = window.location,
36
37	// Map over jQuery in case of overwrite
38	_jQuery = window.jQuery,
39
40	// Map over the $ in case of overwrite
41	_$ = window.$,
42
43	// [[Class]] -> type pairs
44	class2type = {},
45
46	// List of deleted data cache ids, so we can reuse them
47	core_deletedIds = [],
48
49	core_version = "1.9.1",
50
51	// Save a reference to some core methods
52	core_concat = core_deletedIds.concat,
53	core_push = core_deletedIds.push,
54	core_slice = core_deletedIds.slice,
55	core_indexOf = core_deletedIds.indexOf,
56	core_toString = class2type.toString,
57	core_hasOwn = class2type.hasOwnProperty,
58	core_trim = core_version.trim,
59
60	// Define a local copy of jQuery
61	jQuery = function( selector, context ) {
62		// The jQuery object is actually just the init constructor 'enhanced'
63		return new jQuery.fn.init( selector, context, rootjQuery );
64	},
65
66	// Used for matching numbers
67	core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
68
69	// Used for splitting on whitespace
70	core_rnotwhite = /\S+/g,
71
72	// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
73	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
74
75	// A simple way to check for HTML strings
76	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
77	// Strict HTML recognition (#11290: must start with <)
78	rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,
79
80	// Match a standalone tag
81	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
82
83	// JSON RegExp
84	rvalidchars = /^[\],:{}\s]*$/,
85	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
86	rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
87	rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,
88
89	// Matches dashed string for camelizing
90	rmsPrefix = /^-ms-/,
91	rdashAlpha = /-([\da-z])/gi,
92
93	// Used by jQuery.camelCase as callback to replace()
94	fcamelCase = function( all, letter ) {
95		return letter.toUpperCase();
96	},
97
98	// The ready event handler
99	completed = function( event ) {
100
101		// readyState === "complete" is good enough for us to call the dom ready in oldIE
102		if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {
103			detach();
104			jQuery.ready();
105		}
106	},
107	// Clean-up method for dom ready events
108	detach = function() {
109		if ( document.addEventListener ) {
110			document.removeEventListener( "DOMContentLoaded", completed, false );
111			window.removeEventListener( "load", completed, false );
112
113		} else {
114			document.detachEvent( "onreadystatechange", completed );
115			window.detachEvent( "onload", completed );
116		}
117	};
118
119jQuery.fn = jQuery.prototype = {
120	// The current version of jQuery being used
121	jquery: core_version,
122
123	constructor: jQuery,
124	init: function( selector, context, rootjQuery ) {
125		var match, elem;
126
127		// HANDLE: $(""), $(null), $(undefined), $(false)
128		if ( !selector ) {
129			return this;
130		}
131
132		// Handle HTML strings
133		if ( typeof selector === "string" ) {
134			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
135				// Assume that strings that start and end with <> are HTML and skip the regex check
136				match = [ null, selector, null ];
137
138			} else {
139				match = rquickExpr.exec( selector );
140			}
141
142			// Match html or make sure no context is specified for #id
143			if ( match && (match[1] || !context) ) {
144
145				// HANDLE: $(html) -> $(array)
146				if ( match[1] ) {
147					context = context instanceof jQuery ? context[0] : context;
148
149					// scripts is true for back-compat
150					jQuery.merge( this, jQuery.parseHTML(
151						match[1],
152						context && context.nodeType ? context.ownerDocument || context : document,
153						true
154					) );
155
156					// HANDLE: $(html, props)
157					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
158						for ( match in context ) {
159							// Properties of context are called as methods if possible
160							if ( jQuery.isFunction( this[ match ] ) ) {
161								this[ match ]( context[ match ] );
162
163							// ...and otherwise set as attributes
164							} else {
165								this.attr( match, context[ match ] );
166							}
167						}
168					}
169
170					return this;
171
172				// HANDLE: $(#id)
173				} else {
174					elem = document.getElementById( match[2] );
175
176					// Check parentNode to catch when Blackberry 4.6 returns
177					// nodes that are no longer in the document #6963
178					if ( elem && elem.parentNode ) {
179						// Handle the case where IE and Opera return items
180						// by name instead of ID
181						if ( elem.id !== match[2] ) {
182							return rootjQuery.find( selector );
183						}
184
185						// Otherwise, we inject the element directly into the jQuery object
186						this.length = 1;
187						this[0] = elem;
188					}
189
190					this.context = document;
191					this.selector = selector;
192					return this;
193				}
194
195			// HANDLE: $(expr, $(...))
196			} else if ( !context || context.jquery ) {
197				return ( context || rootjQuery ).find( selector );
198
199			// HANDLE: $(expr, context)
200			// (which is just equivalent to: $(context).find(expr)
201			} else {
202				return this.constructor( context ).find( selector );
203			}
204
205		// HANDLE: $(DOMElement)
206		} else if ( selector.nodeType ) {
207			this.context = this[0] = selector;
208			this.length = 1;
209			return this;
210
211		// HANDLE: $(function)
212		// Shortcut for document ready
213		} else if ( jQuery.isFunction( selector ) ) {
214			return rootjQuery.ready( selector );
215		}
216
217		if ( selector.selector !== undefined ) {
218			this.selector = selector.selector;
219			this.context = selector.context;
220		}
221
222		return jQuery.makeArray( selector, this );
223	},
224
225	// Start with an empty selector
226	selector: "",
227
228	// The default length of a jQuery object is 0
229	length: 0,
230
231	// The number of elements contained in the matched element set
232	size: function() {
233		return this.length;
234	},
235
236	toArray: function() {
237		return core_slice.call( this );
238	},
239
240	// Get the Nth element in the matched element set OR
241	// Get the whole matched element set as a clean array
242	get: function( num ) {
243		return num == null ?
244
245			// Return a 'clean' array
246			this.toArray() :
247
248			// Return just the object
249			( num < 0 ? this[ this.length + num ] : this[ num ] );
250	},
251
252	// Take an array of elements and push it onto the stack
253	// (returning the new matched element set)
254	pushStack: function( elems ) {
255
256		// Build a new jQuery matched element set
257		var ret = jQuery.merge( this.constructor(), elems );
258
259		// Add the old object onto the stack (as a reference)

260		ret.prevObject = this;
261		ret.context = this.context;
262
263		// Return the newly-formed element set
264		return ret;
265	},
266
267	// Execute a callback for every element in the matched set.
268	// (You can seed the arguments with an array of args, but this is
269	// only used internally.)
270	each: function( callback, args ) {
271		return jQuery.each( this, callback, args );
272	},
273
274	ready: function( fn ) {
275		// Add the callback
276		jQuery.ready.promise().done( fn );
277
278		return this;
279	},
280
281	slice: function() {
282		return this.pushStack( core_slice.apply( this, arguments ) );
283	},
284
285	first: function() {
286		return this.eq( 0 );
287	},
288
289	last: function() {
290		return this.eq( -1 );
291	},
292
293	eq: function( i ) {
294		var len = this.length,
295			j = +i + ( i < 0 ? len : 0 );
296		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
297	},
298
299	map: function( callback ) {
300		return this.pushStack( jQuery.map(this, function( elem, i ) {
301			return callback.call( elem, i, elem );
302		}));
303	},
304
305	end: function() {
306		return this.prevObject || this.constructor(null);
307	},
308
309	// For internal use only.
310	// Behaves like an Array's method, not like a jQuery method.
311	push: core_push,
312	sort: [].sort,
313	splice: [].splice
314};
315
316// Give the init function the jQuery prototype for later instantiation
317jQuery.fn.init.prototype = jQuery.fn;
318
319jQuery.extend = jQuery.fn.extend = function() {
320	var src, copyIsArray, copy, name, options, clone,
321		target = arguments[0] || {},
322		i = 1,
323		length = arguments.length,
324		deep = false;
325
326	// Handle a deep copy situation
327	if ( typeof target === "boolean" ) {
328		deep = target;
329		target = arguments[1] || {};
330		// skip the boolean and the target
331		i = 2;
332	}
333
334	// Handle case when target is a string or something (possible in deep copy)
335	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
336		target = {};
337	}
338
339	// extend jQuery itself if only one argument is passed
340	if ( length === i ) {
341		target = this;
342		--i;
343	}
344
345	for ( ; i < length; i++ ) {
346		// Only deal with non-null/undefined values
347		if ( (options = arguments[ i ]) != null ) {
348			// Extend the base object
349			for ( name in options ) {
350				src = target[ name ];
351				copy = options[ name ];
352
353				// Prevent never-ending loop
354				if ( target === copy ) {
355					continue;
356				}
357
358				// Recurse if we're merging plain objects or arrays
359				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
360					if ( copyIsArray ) {
361						copyIsArray = false;
362						clone = src && jQuery.isArray(src) ? src : [];
363
364					} else {
365						clone = src && jQuery.isPlainObject(src) ? src : {};
366					}
367
368					// Never move original objects, clone them
369					target[ name ] = jQuery.extend( deep, clone, copy );
370
371				// Don't bring in undefined values
372				} else if ( copy !== undefined ) {
373					target[ name ] = copy;
374				}
375			}
376		}
377	}
378
379	// Return the modified object
380	return target;
381};
382
383jQuery.extend({
384	noConflict: function( deep ) {
385		if ( window.$ === jQuery ) {
386			window.$ = _$;
387		}
388
389		if ( deep && window.jQuery === jQuery ) {
390			window.jQuery = _jQuery;
391		}
392
393		return jQuery;
394	},
395
396	// Is the DOM ready to be used? Set to true once it occurs.
397	isReady: false,
398
399	// A counter to track how many items to wait for before
400	// the ready event fires. See #6781
401	readyWait: 1,
402
403	// Hold (or release) the ready event
404	holdReady: function( hold ) {
405		if ( hold ) {
406			jQuery.readyWait++;
407		} else {
408			jQuery.ready( true );
409		}
410	},
411
412	// Handle when the DOM is ready
413	ready: function( wait ) {
414
415		// Abort if there are pending holds or we're already ready
416		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
417			return;
418		}
419
420		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
421		if ( !document.body ) {
422			return setTimeout( jQuery.ready );
423		}
424
425		// Remember that the DOM is ready
426		jQuery.isReady = true;
427
428		// If a normal DOM Ready event fired, decrement, and wait if need be
429		if ( wait !== true && --jQuery.readyWait > 0 ) {
430			return;
431		}
432
433		// If there are functions bound, to execute
434		readyList.resolveWith( document, [ jQuery ] );
435
436		// Trigger any bound ready events
437		if ( jQuery.fn.trigger ) {
438			jQuery( document ).trigger("ready").off("ready");
439		}
440	},
441
442	// See test/unit/core.js for details concerning isFunction.
443	// Since version 1.3, DOM methods and functions like alert
444	// aren't supported. They return false on IE (#2968).
445	isFunction: function( obj ) {
446		return jQuery.type(obj) === "function";
447	},
448
449	isArray: Array.isArray || function( obj ) {
450		return jQuery.type(obj) === "array";
451	},
452
453	isWindow: function( obj ) {
454		return obj != null && obj == obj.window;
455	},
456
457	isNumeric: function( obj ) {
458		return !isNaN( parseFloat(obj) ) && isFinite( obj );
459	},
460
461	type: function( obj ) {
462		if ( obj == null ) {
463			return String( obj );
464		}
465		return typeof obj === "object" || typeof obj === "function" ?
466			class2type[ core_toString.call(obj) ] || "object" :
467			typeof obj;
468	},
469
470	isPlainObject: function( obj ) {
471		// Must be an Object.
472		// Because of IE, we also have to check the presence of the constructor property.
473		// Make sure that DOM nodes and window objects don't pass through, as well
474		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
475			return false;
476		}
477
478		try {
479			// Not own constructor property must be Object
480			if ( obj.constructor &&
481				!core_hasOwn.call(obj, "constructor") &&
482				!core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
483				return false;
484			}
485		} catch ( e ) {
486			// IE8,9 Will throw exceptions on certain host objects #9897
487			return false;
488		}
489
490		// Own properties are enumerated firstly, so to speed up,
491		// if last one is own, then all properties are own.
492
493		var key;
494		for ( key in obj ) {}
495
496		return key === undefined || core_hasOwn.call( obj, key );
497	},
498
499	isEmptyObject: function( obj ) {
500		var name;
501		for ( name in obj ) {
502			return false;
503		}
504		return true;
505	},
506
507	error: function( msg ) {
508		throw new Error( msg );
509	},
510
511	// data: string of html
512	// context (optional): If specified, the fragment will be created in this context, defaults to document
513	// keepScripts (optional): If true, will include scripts passed in the html string
514	parseHTML: function( data, context, keepScripts ) {
515		if ( !data || typeof data !== "string" ) {
516			return null;
517		}
518		if ( typeof context === "boolean" ) {
519			keepScripts = context;
520			context = false;
521		}
522		context = context || document;
523
524		var parsed = rsingleTag.exec( data ),
525			scripts = !keepScripts && [];
526
527		// Single tag
528		if ( parsed ) {
529			return [ context.createElement( parsed[1] ) ];
530		}
531
532		parsed = jQuery.buildFragment( [ data ], context, scripts );
533		if ( scripts ) {
534			jQuery( scripts ).remove();
535		}
536		return jQuery.merge( [], parsed.childNodes );
537	},
538
539	parseJSON: function( data ) {
540		// Attempt to parse using the native JSON parser first
541		if ( window.JSON && window.JSON.parse ) {
542			return window.JSON.parse( data );
543		}
544
545		if ( data === null ) {
546			return data;
547		}
548
549		if ( typeof data === "string" ) {
550
551			// Make sure leading/trailing whitespace is removed (IE can't handle it)
552			data = jQuery.trim( data );
553
554			if ( data ) {
555				// Make sure the incoming data is actual JSON
556				// Logic borrowed from http://json.org/json2.js
557				if ( rvalidchars.test( data.replace( rvalidescape, "@" )
558					.replace( rvalidtokens, "]" )
559					.replace( rvalidbraces, "")) ) {
560
561					return ( new Function( "return " + data ) )();
562				}
563			}
564		}
565
566		jQuery.error( "Invalid JSON: " + data );
567	},
568
569	// Cross-browser xml parsing
570	parseXML: function( data ) {
571		var xml, tmp;
572		if ( !data || typeof data !== "string" ) {
573			return null;
574		}
575		try {
576			if ( window.DOMParser ) { // Standard
577				tmp = new DOMParser();
578				xml = tmp.parseFromString( data , "text/xml" );
579			} else { // IE
580				xml = new ActiveXObject( "Microsoft.XMLDOM" );
581				xml.async = "false";
582				xml.loadXML( data );
583			}
584		} catch( e ) {
585			xml = undefined;
586		}
587		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
588			jQuery.error( "Invalid XML: " + data );
589		}
590		return xml;
591	},
592
593	noop: function() {},
594
595	// Evaluates a script in a global context
596	// Workarounds based on findings by Jim Driscoll
597	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
598	globalEval: function( data ) {
599		if ( data && jQuery.trim( data ) ) {
600			// We use execScript on Internet Explorer
601			// We use an anonymous function so that context is window
602			// rather than jQuery in Firefox
603			( window.execScript || function( data ) {
604				window[ "eval" ].call( window, data );
605			} )( data );
606		}
607	},
608
609	// Convert dashed to camelCase; used by the css and data modules
610	// Microsoft forgot to hump their vendor prefix (#9572)
611	camelCase: function( string ) {
612		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
613	},
614

615	nodeName: function( elem, name ) {
616		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
617	},
618
619	// args is for internal usage only
620	each: function( obj, callback, args ) {
621		var value,
622			i = 0,
623			length = obj.length,
624			isArray = isArraylike( obj );
625
626		if ( args ) {
627			if ( isArray ) {
628				for ( ; i < length; i++ ) {
629					value = callback.apply( obj[ i ], args );
630
631					if ( value === false ) {
632						break;
633					}
634				}
635			} else {
636				for ( i in obj ) {
637					value = callback.apply( obj[ i ], args );
638
639					if ( value === false ) {
640						break;
641					}
642				}
643			}
644
645		// A special, fast, case for the most common use of each
646		} else {
647			if ( isArray ) {
648				for ( ; i < length; i++ ) {
649					value = callback.call( obj[ i ], i, obj[ i ] );
650
651					if ( value === false ) {
652						break;
653					}
654				}
655			} else {
656				for ( i in obj ) {
657					value = callback.call( obj[ i ], i, obj[ i ] );
658
659					if ( value === false ) {
660						break;
661					}
662				}
663			}
664		}
665
666		return obj;
667	},
668
669	// Use native String.trim function wherever possible
670	trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
671		function( text ) {
672			return text == null ?
673				"" :
674				core_trim.call( text );
675		} :
676
677		// Otherwise use our own trimming functionality
678		function( text ) {
679			return text == null ?
680				"" :
681				( text + "" ).replace( rtrim, "" );
682		},
683
684	// results is for internal usage only
685	makeArray: function( arr, results ) {
686		var ret = results || [];
687
688		if ( arr != null ) {
689			if ( isArraylike( Object(arr) ) ) {
690				jQuery.merge( ret,
691					typeof arr === "string" ?
692					[ arr ] : arr
693				);
694			} else {
695				core_push.call( ret, arr );
696			}
697		}
698
699		return ret;
700	},
701
702	inArray: function( elem, arr, i ) {
703		var len;
704
705		if ( arr ) {
706			if ( core_indexOf ) {
707				return core_indexOf.call( arr, elem, i );
708			}
709
710			len = arr.length;
711			i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
712
713			for ( ; i < len; i++ ) {
714				// Skip accessing in sparse arrays
715				if ( i in arr && arr[ i ] === elem ) {
716					return i;
717				}
718			}
719		}
720
721		return -1;
722	},
723
724	merge: function( first, second ) {
725		var l = second.length,
726			i = first.length,
727			j = 0;
728
729		if ( typeof l === "number" ) {
730			for ( ; j < l; j++ ) {
731				first[ i++ ] = second[ j ];
732			}
733		} else {
734			while ( second[j] !== undefined ) {
735				first[ i++ ] = second[ j++ ];
736			}
737		}
738
739		first.length = i;
740
741		return first;
742	},
743
744	grep: function( elems, callback, inv ) {
745		var retVal,
746			ret = [],
747			i = 0,
748			length = elems.length;
749		inv = !!inv;
750
751		// Go through the array, only saving the items
752		// that pass the validator function
753		for ( ; i < length; i++ ) {
754			retVal = !!callback( elems[ i ], i );
755			if ( inv !== retVal ) {
756				ret.push( elems[ i ] );
757			}
758		}
759
760		return ret;
761	},
762
763	// arg is for internal usage only
764	map: function( elems, callback, arg ) {
765		var value,
766			i = 0,
767			length = elems.length,
768			isArray = isArraylike( elems ),
769			ret = [];
770
771		// Go through the array, translating each of the items to their
772		if ( isArray ) {
773			for ( ; i < length; i++ ) {
774				value = callback( elems[ i ], i, arg );
775
776				if ( value != null ) {
777					ret[ ret.length ] = value;
778				}
779			}
780
781		// Go through every key on the object,
782		} else {
783			for ( i in elems ) {
784				value = callback( elems[ i ], i, arg );
785
786				if ( value != null ) {
787					ret[ ret.length ] = value;
788				}
789			}
790		}
791
792		// Flatten any nested arrays
793		return core_concat.apply( [], ret );
794	},
795
796	// A global GUID counter for objects
797	guid: 1,
798
799	// Bind a function to a context, optionally partially applying any
800	// arguments.
801	proxy: function( fn, context ) {
802		var args, proxy, tmp;
803
804		if ( typeof context === "string" ) {
805			tmp = fn[ context ];
806			context = fn;
807			fn = tmp;
808		}
809
810		// Quick check to determine if target is callable, in the spec
811		// this throws a TypeError, but we will just return undefined.
812		if ( !jQuery.isFunction( fn ) ) {
813			return undefined;
814		}
815
816		// Simulated bind
817		args = core_slice.call( arguments, 2 );
818		proxy = function() {
819			return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) );
820		};
821
822		// Set the guid of unique handler to the same of original handler, so it can be removed
823		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
824
825		return proxy;
826	},
827
828	// Multifunctional method to get and set values of a collection
829	// The value/s can optionally be executed if it's a function
830	access: function( elems, fn, key, value, chainable, emptyGet, raw ) {
831		var i = 0,
832			length = elems.length,
833			bulk = key == null;
834
835		// Sets many values
836		if ( jQuery.type( key ) === "object" ) {
837			chainable = true;
838			for ( i in key ) {
839				jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
840			}
841
842		// Sets one value
843		} else if ( value !== undefined ) {
844			chainable = true;
845
846			if ( !jQuery.isFunction( value ) ) {
847				raw = true;
848			}
849
850			if ( bulk ) {
851				// Bulk operations run against the entire set
852				if ( raw ) {
853					fn.call( elems, value );
854					fn = null;
855
856				// ...except when executing function values
857				} else {
858					bulk = fn;
859					fn = function( elem, key, value ) {
860						return bulk.call( jQuery( elem ), value );
861					};
862				}
863			}
864
865			if ( fn ) {
866				for ( ; i < length; i++ ) {
867					fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
868				}
869			}
870		}
871
872		return chainable ?
873			elems :
874
875			// Gets
876			bulk ?
877				fn.call( elems ) :
878				length ? fn( elems[0], key ) : emptyGet;
879	},
880
881	now: function() {
882		return ( new Date() ).getTime();
883	}
884});
885
886jQuery.ready.promise = function( obj ) {
887	if ( !readyList ) {
888
889		readyList = jQuery.Deferred();
890
891		// Catch cases where $(document).ready() is called after the browser event has already occurred.
892		// we once tried to use readyState "interactive" here, but it caused issues like the one
893		// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
894		if ( document.readyState === "complete" ) {
895			// Handle it asynchronously to allow scripts the opportunity to delay ready
896			setTimeout( jQuery.ready );
897
898		// Standards-based browsers support DOMContentLoaded
899		} else if ( document.addEventListener ) {
900			// Use the handy event callback
901			document.addEventListener( "DOMContentLoaded", completed, false );
902
903			// A fallback to window.onload, that will always work
904			window.addEventListener( "load", completed, false );
905
906		// If IE event model is used
907		} else {
908			// Ensure firing before onload, maybe late but safe also for iframes
909			document.attachEvent( "onreadystatechange", completed );
910
911			// A fallback to window.onload, that will always work
912			window.attachEvent( "onload", completed );
913
914			// If IE and not a frame
915			// continually check to see if the document is ready
916			var top = false;
917
918			try {
919				top = window.frameElement == null && document.documentElement;
920			} catch(e) {}
921
922			if ( top && top.doScroll ) {
923				(function doScrollCheck() {
924					if ( !jQuery.isReady ) {
925
926						try {
927							// Use the trick by Diego Perini
928							// http://javascript.nwbox.com/IEContentLoaded/
929							top.doScroll("left");
930						} catch(e) {
931							return setTimeout( doScrollCheck, 50 );
932						}
933
934						// detach all dom ready events
935						detach();
936
937						// and execute any waiting functions
938						jQuery.ready();
939					}
940				})();
941			}
942		}
943	}
944	return readyList.promise( obj );
945};
946
947// Populate the class2type map
948jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
949	class2type[ "[object " + name + "]" ] = name.toLowerCase();
950});
951
952function isArraylike( obj ) {
953	var length = obj.length,
954		type = jQuery.type( obj );
955
956	if ( jQuery.isWindow( obj ) ) {
957		return false;
958	}
959
960	if ( obj.nodeType === 1 && length ) {
961		return true;
962	}
963
964	return type === "array" || type !== "function" &&
965		( length === 0 ||
966		typeof length === "number" && length > 0 && ( length - 1 ) in obj );
967}
968
969// All jQuery objects should point back to these
970rootjQuery = jQuery(document);
971// String to Object options format cache
972var optionsCache = {};
973
974// Convert String-formatted options into Object-formatted ones and store in cache
975function createOptions( options ) {
976	var object = optionsCache[ options ] = {};
977	jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {
978		object[ flag ] = true;
979	});
980	return object;
981}
982
983/*
984 * Create a callback list using the following parameters:
985 *
986 *	options: an optional list of space-separated options that will change how
987 *			the callback list behaves or a more traditional option object
988 *
989 * By default a callback list will act like an event callback list and can be
990 * "fired" multiple times.
991 *
992 * Possible options:
993 *
994 *	once:			will ensure the callback list can only be fired once (like a Deferred)
995 *
996 *	memory:			will keep track of previous values and will call any callback added
997 *					after the list has been fired right away with the latest "memorized"
998 *					values (like a Deferred)
999 *
1000 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
1001 *
1002 *	stopOnFalse:	interrupt callings when a callback returns false
1003 *
1004 */
1005jQuery.Callbacks = function( options ) {
1006
1007	// Convert options from String-formatted to Object-formatted if needed
1008	// (we check in cache first)
1009	options = typeof options === "string" ?
1010		( optionsCache[ options ] || createOptions( options ) ) :
1011		jQuery.extend( {}, options );
1012
1013	var // Flag to know if list is currently firing
1014		firing,
1015		// Last fire value (for non-forgettable lists)
1016		memory,
1017		// Flag to know if list was already fired
1018		fired,
1019		// End of the loop when firing
1020		firingLength,
1021		// Index of currently firing callback (modified by remove if needed)
1022		firingIndex,
1023		// First callback to fire (used internally by add and fireWith)
1024		firingStart,
1025		// Actual callback list
1026		list = [],
1027		// Stack of fire calls for repeatable lists
1028		stack = !options.once && [],
1029		// Fire callbacks
1030		fire = function( data ) {
1031			memory = options.memory && data;
1032			fired = true;
1033			firingIndex = firingStart || 0;
1034			firingStart = 0;
1035			firingLength = list.length;
1036			firing = true;
1037			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
1038				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
1039					memory = false; // To prevent further calls using add
1040					break;
1041				}
1042			}
1043			firing = false;
1044			if ( list ) {
1045				if ( stack ) {
1046					if ( stack.length ) {
1047						fire( stack.shift() );
1048					}
1049				} else if ( memory ) {
1050					list = [];
1051				} else {
1052					self.disable();
1053				}
1054			}
1055		},
1056		// Actual Callbacks object
1057		self = {
1058			// Add a callback or a collection of callbacks to the list
1059			add: function() {
1060				if ( list ) {
1061					// First, we save the current length
1062					var start = list.length;
1063					(function add( args ) {
1064						jQuery.each( args, function( _, arg ) {
1065							var type = jQuery.type( arg );
1066							if ( type === "function" ) {
1067								if ( !options.unique || !self.has( arg ) ) {
1068									list.push( arg );
1069								}
1070							} else if ( arg && arg.length && type !== "string" ) {
1071								// Inspect recursively
1072								add( arg );
1073							}
1074						});
1075					})( arguments );
1076					// Do we need to add the callbacks to the
1077					// current firing batch?
1078					if ( firing ) {
1079						firingLength = list.length;
1080					// With memory, if we're not firing then
1081					// we should call right away
1082					} else if ( memory ) {
1083						firingStart = start;
1084						fire( memory );
1085					}
1086				}
1087				return this;
1088			},
1089			// Remove a callback from the list
1090			remove: function() {
1091				if ( list ) {
1092					jQuery.each( arguments, function( _, arg ) {
1093						var index;
1094						while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
1095							list.splice( index, 1 );
1096							// Handle firing indexes
1097							if ( firing ) {
1098								if ( index <= firingLength ) {
1099									firingLength--;
1100								}
1101								if ( index <= firingIndex ) {
1102									firingIndex--;
1103								}
1104							}
1105						}
1106					});
1107				}
1108				return this;
1109			},
1110			// Check if a given callback is in the list.
1111			// If no argument is given, return whether or not list has callbacks attached.
1112			has: function( fn ) {
1113				return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
1114			},
1115			// Remove all callbacks from the list
1116			empty: function() {
1117				list = [];
1118				return this;
1119			},
1120			// Have the list do nothing anymore
1121			disable: function() {
1122				list = stack = memory = undefined;
1123				return this;
1124			},
1125			// Is it disabled?
1126			disabled: function() {
1127				return !list;
1128			},
1129			// Lock the list in its current state
1130			lock: function() {
1131				stack = undefined;
1132				if ( !memory ) {
1133					self.disable();
1134				}
1135				return this;
1136			},
1137			// Is it locked?
1138			locked: function() {
1139				return !stack;
1140			},
1141			// Call all callbacks with the given context and arguments
1142			fireWith: function( context, args ) {
1143				args = args || [];
1144				args = [ context, args.slice ? args.slice() : args ];
1145				if ( list && ( !fired || stack ) ) {
1146					if ( firing ) {
1147						stack.push( args );
1148					} else {
1149						fire( args );
1150					}
1151				}
1152				return this;
1153			},
1154			// Call all the callbacks with the given arguments
1155			fire: function() {
1156				self.fireWith( this, arguments );
1157				return this;
1158			},
1159			// To know if the callbacks have already been called at least once
1160			fired: function() {
1161				return !!fired;
1162			}
1163		};
1164
1165	return self;
1166};
1167jQuery.extend({
1168
1169	Deferred: function( func ) {
1170		var tuples = [
1171				// action, add listener, listener list, final state
1172				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
1173				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
1174				[ "notify", "progress", jQuery.Callbacks("memory") ]
1175			],
1176			state = "pending",
1177			promise = {
1178				state: function() {
1179					return state;
1180				},
1181				always: function() {
1182					deferred.done( arguments ).fail( arguments );
1183					return this;
1184				},
1185				then: function( /* fnDone, fnFail, fnProgress */ ) {
1186					var fns = arguments;
1187					return jQuery.Deferred(function( newDefer ) {
1188						jQuery.each( tuples, function( i, tuple ) {
1189							var action = tuple[ 0 ],
1190								fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
1191							// deferred[ done | fail | progress ] for forwarding actions to newDefer
1192							deferred[ tuple[1] ](function() {
1193								var returned = fn && fn.apply( this, arguments );
1194								if ( returned && jQuery.isFunction( returned.promise ) ) {
1195									returned.promise()
1196										.done( newDefer.resolve )
1197										.fail( newDefer.reject )
1198										.progress( newDefer.notify );
1199								} else {
1200									newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
1201								}
1202							});
1203						});
1204						fns = null;
1205					}).promise();
1206				},
1207				// Get a promise for this deferred
1208				// If obj is provided, the promise aspect is added to the object
1209				promise: function( obj ) {
1210					return obj != null ? jQuery.extend( obj, promise ) : promise;
1211				}
1212			},
1213			deferred = {};
1214
1215		// Keep pipe for back-compat
1216		promise.pipe = promise.then;
1217
1218		// Add list-specific methods
1219		jQuery.each( tuples, function( i, tuple ) {
1220			var list = tuple[ 2 ],
1221				stateString = tuple[ 3 ];
1222
1223			// promise[ done | fail | progress ] = list.add
1224			promise[ tuple[1] ] = list.add;
1225
1226			// Handle state
1227			if ( stateString ) {
1228				list.add(function() {
1229					// state = [ resolved | rejected ]
1230					state = stateString;
1231
1232				// [ reject_list | resolve_list ].disable; progress_list.lock
1233				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
1234			}
1235
1236			// deferred[ resolve | reject | notify ]
1237			deferred[ tuple[0] ] = function() {
1238				deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
1239				return this;
1240			};
1241			deferred[ tuple[0] + "With" ] = list.fireWith;
1242		});
1243
1244		// Make the deferred a promise
1245		promise.promise( deferred );
1246
1247		// Call given func if any
1248		if ( func ) {
1249			func.call( deferred, deferred );
1250		}
1251
1252		// All done!
1253		return deferred;
1254	},
1255
1256	// Deferred helper
1257	when: function( subordinate /* , ..., subordinateN */ ) {
1258		var i = 0,
1259			resolveValues = core_slice.call( arguments ),
1260			length = resolveValues.length,
1261
1262			// the count of uncompleted subordinates
1263			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
1264
1265			// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
1266			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
1267
1268			// Update function for both resolve and progress values
1269			updateFunc = function( i, contexts, values ) {
1270				return function( value ) {
1271					contexts[ i ] = this;
1272					values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
1273					if( values === progressValues ) {
1274						deferred.notifyWith( contexts, values );
1275					} else if ( !( --remaining ) ) {
1276						deferred.resolveWith( contexts, values );
1277					}
1278				};
1279			},
1280
1281			progressValues, progressContexts, resolveContexts;
1282
1283		// add listeners to Deferred subordinates; treat others as resolved
1284		if ( length > 1 ) {
1285			progressValues = new Array( length );
1286			progressContexts = new Array( length );
1287			resolveContexts = new Array( length );
1288			for ( ; i < length; i++ ) {
1289				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
1290					resolveValues[ i ].promise()
1291						.done( updateFunc( i, resolveContexts, resolveValues ) )
1292						.fail( deferred.reject )
1293						.progress( updateFunc( i, progressContexts, progressValues ) );
1294				} else {
1295					--remaining;
1296				}
1297			}
1298		}
1299
1300		// if we're not waiting on anything, resolve the master
1301		if ( !remaining ) {
1302			deferred.resolveWith( resolveContexts, resolveValues );
1303		}
1304
1305		return deferred.promise();
1306	}
1307});
1308jQuery.support = (function() {
1309
1310	var support, all, a,
1311		input, select, fragment,
1312		opt, eventName, isSupported, i,
1313		div = document.createElement("div");
1314
1315	// Setup
1316	div.setAttribute( "className", "t" );
1317	div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
1318
1319	// Support tests won't run in some limited or non-browser environments
1320	all = div.getElementsByTagName("*");
1321	a = div.getElementsByTagName("a")[ 0 ];
1322	if ( !all || !a || !all.length ) {
1323		return {};
1324	}
1325
1326	// First batch of tests
1327	select = document.createElement("select");
1328	opt = select.appendChild( document.createElement("option") );
1329	input = div.getElementsByTagName("input")[ 0 ];
1330
1331	a.style.cssText = "top:1px;float:left;opacity:.5";
1332	support = {
1333		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1334		getSetAttribute: div.className !== "t",
1335
1336		// IE strips leading whitespace when .innerHTML is used
1337		leadingWhitespace: div.firstChild.nodeType === 3,
1338
1339		// Make sure that tbody elements aren't automatically inserted
1340		// IE will insert them into empty tables
1341		tbody: !div.getElementsByTagName("tbody").length,
1342
1343		// Make sure that link elements get serialized correctly by innerHTML
1344		// This requires a wrapper element in IE
1345		htmlSerialize: !!div.getElementsByTagName("link").length,
1346
1347		// Get the style information from getAttribute
1348		// (IE uses .cssText instead)
1349		style: /top/.test( a.getAttribute("style") ),
1350
1351		// Make sure that URLs aren't manipulated
1352		// (IE normalizes it by default)
1353		hrefNormalized: a.getAttribute("href") === "/a",
1354
1355		// Make sure that element opacity exists
1356		// (IE uses filter instead)
1357		// Use a regex to work around a WebKit issue. See #5145

1448		support[ i + "Bubbles" ] = eventName in window || div.attributes[ eventName ].expando === false;
1449	}
1450
1451	div.style.backgroundClip = "content-box";
1452	div.cloneNode( true ).style.backgroundClip = "";
1453	support.clearCloneStyle = div.style.backgroundClip === "content-box";
1454
1455	// Run tests that need a body at doc ready
1456	jQuery(function() {
1457		var container, marginDiv, tds,
1458			divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",
1459			body = document.getElementsByTagName("body")[0];
1460
1461		if ( !body ) {
1462			// Return for frameset docs that don't have a body
1463			return;
1464		}
1465
1466		container = document.createElement("div");
1467		container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";
1468
1469		body.appendChild( container ).appendChild( div );
1470
1471		// Support: IE8
1472		// Check if table cells still have offsetWidth/Height when they are set
1473		// to display:none and there are still other visible table cells in a
1474		// table row; if so, offsetWidth/Height are not reliable for use when
1475		// determining if an element has been hidden directly using
1476		// display:none (it is still safe to use offsets if a parent element is
1477		// hidden; don safety goggles and see bug #4512 for more information).
1478		div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
1479		tds = div.getElementsByTagName("td");
1480		tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
1481		isSupported = ( tds[ 0 ].offsetHeight === 0 );
1482
1483		tds[ 0 ].style.display = "";
1484		tds[ 1 ].style.display = "none";
1485
1486		// Support: IE8
1487		// Check if empty table cells still have offsetWidth/Height
1488		support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1489
1490		// Check box-sizing and margin behavior
1491		div.innerHTML = "";
1492		div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
1493		support.boxSizing = ( div.offsetWidth === 4 );
1494		support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
1495
1496		// Use window.getComputedStyle because jsdom on node.js will break without it.
1497		if ( window.getComputedStyle ) {
1498			support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
1499			support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
1500
1501			// Check if div with explicit width and no margin-right incorrectly
1502			// gets computed margin-right based on width of container. (#3333)
1503			// Fails in WebKit before Feb 2011 nightlies
1504			// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1505			marginDiv = div.appendChild( document.createElement("div") );
1506			marginDiv.style.cssText = div.style.cssText = divReset;
1507			marginDiv.style.marginRight = marginDiv.style.width = "0";
1508			div.style.width = "1px";
1509
1510			support.reliableMarginRight =
1511				!parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
1512		}
1513
1514		if ( typeof div.style.zoom !== core_strundefined ) {
1515			// Support: IE<8
1516			// Check if natively block-level elements act like inline-block
1517			// elements when setting their display to 'inline' and giving
1518			// them layout
1519			div.innerHTML = "";
1520			div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
1521			support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
1522
1523			// Support: IE6
1524			// Check if elements with layout shrink-wrap their children
1525			div.style.display = "block";
1526			div.innerHTML = "<div></div>";
1527			div.firstChild.style.width = "5px";
1528			support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
1529
1530			if ( support.inlineBlockNeedsLayout ) {
1531				// Prevent IE 6 from affecting layout for positioned elements #11048
1532				// Prevent IE from shrinking the body in IE 7 mode #12869
1533				// Support: IE<8
1534				body.style.zoom = 1;
1535			}
1536		}
1537
1538		body.removeChild( container );
1539
1540		// Null elements to avoid leaks in IE
1541		container = div = tds = marginDiv = null;
1542	});
1543
1544	// Null elements to avoid leaks in IE
1545	all = select = fragment = opt = a = input = null;
1546
1547	return support;
1548})();
1549
1550var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
1551	rmultiDash = /([A-Z])/g;
1552
1553function internalData( elem, name, data, pvt /* Internal Use Only */ ){
1554	if ( !jQuery.acceptData( elem ) ) {
1555		return;
1556	}
1557
1558	var thisCache, ret,
1559		internalKey = jQuery.expando,
1560		getByName = typeof name === "string",
1561
1562		// We have to handle DOM nodes and JS objects differently because IE6-7
1563		// can't GC object references properly across the DOM-JS boundary
1564		isNode = elem.nodeType,
1565
1566		// Only DOM nodes need the global jQuery cache; JS object data is
1567		// attached directly to the object so GC can occur automatically
1568		cache = isNode ? jQuery.cache : elem,
1569
1570		// Only defining an ID for JS objects if its cache already exists allows
1571		// the code to shortcut on the same path as a DOM node with no cache
1572		id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
1573
1574	// Avoid doing any more work than we need to when trying to get data on an
1575	// object that has no data at all
1576	if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) {
1577		return;
1578	}
1579
1580	if ( !id ) {
1581		// Only DOM nodes need a new unique ID for each element since their data
1582		// ends up in the global cache
1583		if ( isNode ) {
1584			elem[ internalKey ] = id = core_deletedIds.pop() || jQuery.guid++;
1585		} else {
1586			id = internalKey;
1587		}
1588	}
1589
1590	if ( !cache[ id ] ) {
1591		cache[ id ] = {};
1592
1593		// Avoids exposing jQuery metadata on plain JS objects when the object
1594		// is serialized using JSON.stringify
1595		if ( !isNode ) {
1596			cache[ id ].toJSON = jQuery.noop;
1597		}
1598	}
1599
1600	// An object can be passed to jQuery.data instead of a key/value pair; this gets
1601	// shallow copied over onto the existing cache
1602	if ( typeof name === "object" || typeof name === "function" ) {
1603		if ( pvt ) {
1604			cache[ id ] = jQuery.extend( cache[ id ], name );
1605		} else {
1606			cache[ id ].data = jQuery.extend( cache[ id ].data, name );
1607		}
1608	}
1609
1610	thisCache = cache[ id ];
1611
1612	// jQuery data() is stored in a separate object inside the object's internal data
1613	// cache in order to avoid key collisions between internal data and user-defined
1614	// data.
1615	if ( !pvt ) {
1616		if ( !thisCache.data ) {
1617			thisCache.data = {};
1618		}
1619
1620		thisCache = thisCache.data;
1621	}
1622
1623	if ( data !== undefined ) {
1624		thisCache[ jQuery.camelCase( name ) ] = data;
1625	}
1626
1627	// Check for both converted-to-camel and non-converted data property names
1628	// If a data property was specified
1629	if ( getByName ) {
1630
1631		// First Try to find as-is property data
1632		ret = thisCache[ name ];
1633
1634		// Test for null|undefined property data
1635		if ( ret == null ) {
1636
1637			// Try to find the camelCased property
1638			ret = thisCache[ jQuery.camelCase( name ) ];
1639		}
1640	} else {
1641		ret = thisCache;
1642	}
1643
1644	return ret;
1645}
1646
1647function internalRemoveData( elem, name, pvt ) {
1648	if ( !jQuery.acceptData( elem ) ) {
1649		return;
1650	}
1651
1652	var i, l, thisCache,
1653		isNode = elem.nodeType,
1654
1655		// See jQuery.data for more information
1656		cache = isNode ? jQuery.cache : elem,
1657		id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
1658
1659	// If there is already no cache entry for this object, there is no
1660	// purpose in continuing
1661	if ( !cache[ id ] ) {
1662		return;
1663	}
1664
1665	if ( name ) {
1666
1667		thisCache = pvt ? cache[ id ] : cache[ id ].data;
1668
1669		if ( thisCache ) {
1670
1671			// Support array or space separated string names for data keys
1672			if ( !jQuery.isArray( name ) ) {
1673
1674				// try the string as a key before any manipulation
1675				if ( name in thisCache ) {
1676					name = [ name ];
1677				} else {
1678
1679					// split the camel cased version by spaces unless a key with the spaces exists
1680					name = jQuery.camelCase( name );
1681					if ( name in thisCache ) {
1682						name = [ name ];
1683					} else {
1684						name = name.split(" ");
1685					}
1686				}
1687			} else {
1688				// If "name" is an array of keys...
1689				// When data is initially created, via ("key", "val") signature,
1690				// keys will be converted to camelCase.
1691				// Since there is no way to tell _how_ a key was added, remove
1692				// both plain key and camelCase key. #12786
1693				// This will only penalize the array argument path.
1694				name = name.concat( jQuery.map( name, jQuery.camelCase ) );
1695			}
1696
1697			for ( i = 0, l = name.length; i < l; i++ ) {
1698				delete thisCache[ name[i] ];
1699			}
1700
1701			// If there is no data left in the cache, we want to continue
1702			// and let the cache object itself get destroyed
1703			if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
1704				return;
1705			}
1706		}
1707	}
1708
1709	// See jQuery.data for more information
1710	if ( !pvt ) {
1711		delete cache[ id ].data;
1712
1713		// Don't destroy the parent cache unless the internal data object
1714		// had been the only thing left in it
1715		if ( !isEmptyDataObject( cache[ id ] ) ) {
1716			return;
1717		}
1718	}
1719
1720	// Destroy the cache
1721	if ( isNode ) {
1722		jQuery.cleanData( [ elem ], true );
1723
1724	// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
1725	} else if ( jQuery.support.deleteExpando || cache != cache.window ) {
1726		delete cache[ id ];
1727
1728	// When all else fails, null
1729	} else {
1730		cache[ id ] = null;
1731	}
1732}
1733
1734jQuery.extend({
1735	cache: {},
1736
1737	// Unique for each copy of jQuery on the page
1738	// Non-digits removed to match rinlinejQuery
1739	expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ),
1740
1741	// The following elements throw uncatchable exceptions if you
1742	// attempt to add expando properties to them.
1743	noData: {
1744		"embed": true,
1745		// Ban all objects except for Flash (which handle expandos)
1746		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1747		"applet": true
1748	},
1749
1750	hasData: function( elem ) {
1751		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1752		return !!elem && !isEmptyDataObject( elem );
1753	},
1754
1755	data: function( elem, name, data ) {
1756		return internalData( elem, name, data );
1757	},
1758
1759	removeData: function( elem, name ) {
1760		return internalRemoveData( elem, name );
1761	},
1762
1763	// For internal use only.
1764	_data: function( elem, name, data ) {
1765		return internalData( elem, name, data, true );
1766	},
1767
1768	_removeData: function( elem, name ) {
1769		return internalRemoveData( elem, name, true );
1770	},
1771
1772	// A method for determining if a DOM node can handle the data expando
1773	acceptData: function( elem ) {
1774		// Do not set data on non-element because it will not be cleared (#8335).
1775		if ( elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9 ) {
1776			return false;
1777		}
1778
1779		var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];
1780
1781		// nodes accept data unless otherwise specified; rejection can be conditional
1782		return !noData || noData !== true && elem.getAttribute("classid") === noData;
1783	}
1784});
1785
1786jQuery.fn.extend({
1787	data: function( key, value ) {
1788		var attrs, name,
1789			elem = this[0],
1790			i = 0,
1791			data = null;
1792
1793		// Gets all values
1794		if ( key === undefined ) {
1795			if ( this.length ) {
1796				data = jQuery.data( elem );
1797
1798				if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
1799					attrs = elem.attributes;
1800					for ( ; i < attrs.length; i++ ) {
1801						name = attrs[i].name;
1802
1803						if ( !name.indexOf( "data-" ) ) {
1804							name = jQuery.camelCase( name.slice(5) );
1805
1806							dataAttr( elem, name, data[ name ] );
1807						}
1808					}
1809					jQuery._data( elem, "parsedAttrs", true );
1810				}
1811			}
1812
1813			return data;
1814		}
1815
1816		// Sets multiple values
1817		if ( typeof key === "object" ) {
1818			return this.each(function() {
1819				jQuery.data( this, key );
1820			});
1821		}
1822
1823		return jQuery.access( this, function( value ) {
1824
1825			if ( value === undefined ) {
1826				// Try to fetch any internally stored data first
1827				return elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null;
1828			}
1829
1830			this.each(function() {
1831				jQuery.data( this, key, value );
1832			});
1833		}, null, value, arguments.length > 1, null, true );
1834	},
1835
1836	removeData: function( key ) {
1837		return this.each(function() {
1838			jQuery.removeData( this, key );
1839		});
1840	}
1841});
1842
1843function dataAttr( elem, key, data ) {
1844	// If nothing was found internally, try to fetch any
1845	// data from the HTML5 data-* attribute
1846	if ( data === undefined && elem.nodeType === 1 ) {
1847
1848		var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
1849
1850		data = elem.getAttribute( name );
1851
1852		if ( typeof data === "string" ) {
1853			try {
1854				data = data === "true" ? true :
1855					data === "false" ? false :
1856					data === "null" ? null :
1857					// Only convert to a number if it doesn't change the string
1858					+data + "" === data ? +data :
1859					rbrace.test( data ) ? jQuery.parseJSON( data ) :
1860						data;
1861			} catch( e ) {}
1862
1863			// Make sure we set the data so it isn't changed later
1864			jQuery.data( elem, key, data );
1865
1866		} else {
1867			data = undefined;
1868		}
1869	}
1870
1871	return data;
1872}
1873
1874// checks a cache object for emptiness
1875function isEmptyDataObject( obj ) {
1876	var name;
1877	for ( name in obj ) {
1878
1879		// if the public data object is empty, the private is still empty
1880		if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
1881			continue;
1882		}
1883		if ( name !== "toJSON" ) {
1884			return false;
1885		}
1886	}
1887
1888	return true;
1889}
1890jQuery.extend({
1891	queue: function( elem, type, data ) {
1892		var queue;
1893
1894		if ( elem ) {
1895			type = ( type || "fx" ) + "queue";
1896			queue = jQuery._data( elem, type );
1897
1898			// Speed up dequeue by getting out quickly if this is just a lookup
1899			if ( data ) {
1900				if ( !queue || jQuery.isArray(data) ) {
1901					queue = jQuery._data( elem, type, jQuery.makeArray(data) );
1902				} else {
1903					queue.push( data );
1904				}
1905			}
1906			return queue || [];
1907		}
1908	},
1909
1910	dequeue: function( elem, type ) {
1911		type = type || "fx";
1912
1913		var queue = jQuery.queue( elem, type ),
1914			startLength = queue.length,
1915			fn = queue.shift(),
1916			hooks = jQuery._queueHooks( elem, type ),
1917			next = function() {
1918				jQuery.dequeue( elem, type );
1919			};
1920
1921		// If the fx queue is dequeued, always remove the progress sentinel
1922		if ( fn === "inprogress" ) {
1923			fn = queue.shift();
1924			startLength--;
1925		}
1926
1927		hooks.cur = fn;
1928		if ( fn ) {
1929
1930			// Add a progress sentinel to prevent the fx queue from being
1931			// automatically dequeued
1932			if ( type === "fx" ) {
1933				queue.unshift( "inprogress" );
1934			}
1935
1936			// clear up the last queue stop function
1937			delete hooks.stop;
1938			fn.call( elem, next, hooks );
1939		}
1940
1941		if ( !startLength && hooks ) {
1942			hooks.empty.fire();
1943		}
1944	},
1945
1946	// not intended for public consumption - generates a queueHooks object, or returns the current one
1947	_queueHooks: function( elem, type ) {
1948		var key = type + "queueHooks";
1949		return jQuery._data( elem, key ) || jQuery._data( elem, key, {
1950			empty: jQuery.Callbacks("once memory").add(function() {
1951				jQuery._removeData( elem, type + "queue" );
1952				jQuery._removeData( elem, key );
1953			})
1954		});
1955	}
1956});
1957
1958jQuery.fn.extend({
1959	queue: function( type, data ) {
1960		var setter = 2;
1961
1962		if ( typeof type !== "string" ) {
1963			data = type;
1964			type = "fx";
1965			setter--;
1966		}
1967
1968		if ( arguments.length < setter ) {
1969			return jQuery.queue( this[0], type );
1970		}
1971
1972		return data === undefined ?

1973			this :
1974			this.each(function() {
1975				var queue = jQuery.queue( this, type, data );
1976
1977				// ensure a hooks for this queue
1978				jQuery._queueHooks( this, type );
1979
1980				if ( type === "fx" && queue[0] !== "inprogress" ) {
1981					jQuery.dequeue( this, type );
1982				}
1983			});
1984	},
1985	dequeue: function( type ) {
1986		return this.each(function() {
1987			jQuery.dequeue( this, type );
1988		});
1989	},
1990	// Based off of the plugin by Clint Helfers, with permission.
1991	// http://blindsignals.com/index.php/2009/07/jquery-delay/
1992	delay: function( time, type ) {
1993		time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
1994		type = type || "fx";
1995
1996		return this.queue( type, function( next, hooks ) {
1997			var timeout = setTimeout( next, time );
1998			hooks.stop = function() {
1999				clearTimeout( timeout );
2000			};
2001		});
2002	},
2003	clearQueue: function( type ) {
2004		return this.queue( type || "fx", [] );
2005	},
2006	// Get a promise resolved when queues of a certain type
2007	// are emptied (fx is the type by default)
2008	promise: function( type, obj ) {
2009		var tmp,
2010			count = 1,
2011			defer = jQuery.Deferred(),
2012			elements = this,
2013			i = this.length,
2014			resolve = function() {
2015				if ( !( --count ) ) {
2016					defer.resolveWith( elements, [ elements ] );
2017				}
2018			};
2019
2020		if ( typeof type !== "string" ) {
2021			obj = type;
2022			type = undefined;
2023		}
2024		type = type || "fx";
2025
2026		while( i-- ) {
2027			tmp = jQuery._data( elements[ i ], type + "queueHooks" );
2028			if ( tmp && tmp.empty ) {
2029				count++;
2030				tmp.empty.add( resolve );
2031			}
2032		}
2033		resolve();
2034		return defer.promise( obj );
2035	}
2036});
2037var nodeHook, boolHook,
2038	rclass = /[\t\r\n]/g,
2039	rreturn = /\r/g,
2040	rfocusable = /^(?:input|select|textarea|button|object)$/i,
2041	rclickable = /^(?:a|area)$/i,
2042	rboolean = /^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i,
2043	ruseDefault = /^(?:checked|selected)$/i,
2044	getSetAttribute = jQuery.support.getSetAttribute,
2045	getSetInput = jQuery.support.input;
2046
2047jQuery.fn.extend({
2048	attr: function( name, value ) {
2049		return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
2050	},
2051
2052	removeAttr: function( name ) {
2053		return this.each(function() {
2054			jQuery.removeAttr( this, name );
2055		});
2056	},
2057
2058	prop: function( name, value ) {
2059		return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
2060	},
2061
2062	removeProp: function( name ) {
2063		name = jQuery.propFix[ name ] || name;
2064		return this.each(function() {
2065			// try/catch handles cases where IE balks (such as removing a property on window)
2066			try {
2067				this[ name ] = undefined;
2068				delete this[ name ];
2069			} catch( e ) {}
2070		});
2071	},
2072
2073	addClass: function( value ) {
2074		var classes, elem, cur, clazz, j,
2075			i = 0,
2076			len = this.length,
2077			proceed = typeof value === "string" && value;
2078
2079		if ( jQuery.isFunction( value ) ) {
2080			return this.each(function( j ) {
2081				jQuery( this ).addClass( value.call( this, j, this.className ) );
2082			});
2083		}
2084
2085		if ( proceed ) {
2086			// The disjunction here is for better compressibility (see removeClass)
2087			classes = ( value || "" ).match( core_rnotwhite ) || [];
2088
2089			for ( ; i < len; i++ ) {
2090				elem = this[ i ];
2091				cur = elem.nodeType === 1 && ( elem.className ?
2092					( " " + elem.className + " " ).replace( rclass, " " ) :
2093					" "
2094				);
2095
2096				if ( cur ) {
2097					j = 0;
2098					while ( (clazz = classes[j++]) ) {
2099						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
2100							cur += clazz + " ";
2101						}
2102					}
2103					elem.className = jQuery.trim( cur );
2104
2105				}
2106			}
2107		}
2108
2109		return this;
2110	},
2111
2112	removeClass: function( value ) {
2113		var classes, elem, cur, clazz, j,
2114			i = 0,
2115			len = this.length,
2116			proceed = arguments.length === 0 || typeof value === "string" && value;
2117
2118		if ( jQuery.isFunction( value ) ) {
2119			return this.each(function( j ) {
2120				jQuery( this ).removeClass( value.call( this, j, this.className ) );
2121			});
2122		}
2123		if ( proceed ) {
2124			classes = ( value || "" ).match( core_rnotwhite ) || [];
2125
2126			for ( ; i < len; i++ ) {
2127				elem = this[ i ];
2128				// This expression is here for better compressibility (see addClass)
2129				cur = elem.nodeType === 1 && ( elem.className ?
2130					( " " + elem.className + " " ).replace( rclass, " " ) :
2131					""
2132				);
2133
2134				if ( cur ) {
2135					j = 0;
2136					while ( (clazz = classes[j++]) ) {

2137						// Remove *all* instances
2138						while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {
2139							cur = cur.replace( " " + clazz + " ", " " );
2140						}
2141					}
2142					elem.className = value ? jQuery.trim( cur ) : "";
2143				}
2144			}
2145		}
2146
2147		return this;
2148	},
2149
2150	toggleClass: function( value, stateVal ) {
2151		var type = typeof value,
2152			isBool = typeof stateVal === "boolean";
2153
2154		if ( jQuery.isFunction( value ) ) {
2155			return this.each(function( i ) {
2156				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
2157			});
2158		}
2159
2160		return this.each(function() {
2161			if ( type === "string" ) {
2162				// toggle individual class names
2163				var className,
2164					i = 0,
2165					self = jQuery( this ),
2166					state = stateVal,
2167					classNames = value.match( core_rnotwhite ) || [];
2168
2169				while ( (className = classNames[ i++ ]) ) {
2170					// check each className given, space separated list
2171					state = isBool ? state : !self.hasClass( className );
2172					self[ state ? "addClass" : "removeClass" ]( className );
2173				}
2174
2175			// Toggle whole class name
2176			} else if ( type === core_strundefined || type === "boolean" ) {
2177				if ( this.className ) {
2178					// store className if set
2179					jQuery._data( this, "__className__", this.className );
2180				}
2181
2182				// If the element has a class name or if we're passed "false",
2183				// then remove the whole classname (if there was one, the above saved it).
2184				// Otherwise bring back whatever was previously saved (if anything),
2185				// falling back to the empty string if nothing was stored.
2186				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2187			}
2188		});
2189	},
2190
2191	hasClass: function( selector ) {
2192		var className = " " + selector + " ",
2193			i = 0,
2194			l = this.length;
2195		for ( ; i < l; i++ ) {
2196			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
2197				return true;
2198			}
2199		}
2200
2201		return false;
2202	},
2203
2204	val: function( value ) {
2205		var ret, hooks, isFunction,
2206			elem = this[0];
2207
2208		if ( !arguments.length ) {
2209			if ( elem ) {
2210				hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
2211
2212				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2213					return ret;
2214				}
2215
2216				ret = elem.value;
2217
2218				return typeof ret === "string" ?
2219					// handle most common string cases
2220					ret.replace(rreturn, "") :
2221					// handle cases where value is null/undef or number
2222					ret == null ? "" : ret;
2223			}
2224
2225			return;
2226		}
2227
2228		isFunction = jQuery.isFunction( value );
2229
2230		return this.each(function( i ) {
2231			var val,
2232				self = jQuery(this);
2233
2234			if ( this.nodeType !== 1 ) {
2235				return;
2236			}
2237
2238			if ( isFunction ) {
2239				val = value.call( this, i, self.val() );
2240			} else {
2241				val = value;
2242			}
2243
2244			// Treat null/undefined as ""; convert numbers to string
2245			if ( val == null ) {
2246				val = "";
2247			} else if ( typeof val === "number" ) {
2248				val += "";
2249			} else if ( jQuery.isArray( val ) ) {
2250				val = jQuery.map(val, function ( value ) {
2251					return value == null ? "" : value + "";
2252				});
2253			}
2254
2255			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
2256
2257			// If set returns undefined, fall back to normal setting
2258			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
2259				this.value = val;
2260			}
2261		});
2262	}
2263});
2264
2265jQuery.extend({
2266	valHooks: {
2267		option: {
2268			get: function( elem ) {
2269				// attributes.value is undefined in Blackberry 4.7 but
2270				// uses .value. See #6932
2271				var val = elem.attributes.value;
2272				return !val || val.specified ? elem.value : elem.text;
2273			}
2274		},
2275		select: {
2276			get: function( elem ) {
2277				var value, option,
2278					options = elem.options,
2279					index = elem.selectedIndex,
2280					one = elem.type === "select-one" || index < 0,
2281					values = one ? null : [],
2282					max = one ? index + 1 : options.length,
2283					i = index < 0 ?
2284						max :
2285						one ? index : 0;
2286
2287				// Loop through all the selected options
2288				for ( ; i < max; i++ ) {
2289					option = options[ i ];
2290
2291					// oldIE doesn't update selected after form reset (#2551)
2292					if ( ( option.selected || i === index ) &&
2293							// Don't return options that are disabled or in a disabled optgroup
2294							( jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null ) &&
2295							( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
2296
2297						// Get the specific value for the option
2298						value = jQuery( option ).val();
2299
2300						// We don't need an array for one selects
2301						if ( one ) {
2302							return value;
2303						}
2304
2305						// Multi-Selects return an array
2306						values.push( value );
2307					}
2308				}
2309
2310				return values;
2311			},
2312
2313			set: function( elem, value ) {
2314				var values = jQuery.makeArray( value );
2315
2316				jQuery(elem).find("option").each(function() {
2317					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2318				});
2319
2320				if ( !values.length ) {
2321					elem.selectedIndex = -1;
2322				}
2323				return values;
2324			}
2325		}
2326	},
2327
2328	attr: function( elem, name, value ) {
2329		var hooks, notxml, ret,
2330			nType = elem.nodeType;
2331
2332		// don't get/set attributes on text, comment and attribute nodes
2333		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2334			return;
2335		}
2336
2337		// Fallback to prop when attributes are not supported
2338		if ( typeof elem.getAttribute === core_strundefined ) {
2339			return jQuery.prop( elem, name, value );
2340		}
2341
2342		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2343
2344		// All attributes are lowercase
2345		// Grab necessary hook if one is defined
2346		if ( notxml ) {
2347			name = name.toLowerCase();
2348			hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
2349		}
2350
2351		if ( value !== undefined ) {
2352
2353			if ( value === null ) {
2354				jQuery.removeAttr( elem, name );
2355
2356			} else if ( hooks && notxml && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2357				return ret;
2358
2359			} else {
2360				elem.setAttribute( name, value + "" );
2361				return value;
2362			}
2363
2364		} else if ( hooks && notxml && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
2365			return ret;
2366
2367		} else {
2368
2369			// In IE9+, Flash objects don't have .getAttribute (#12945)