https://hongdou.com/en/public/scripts/jquery.js

1/*!
2 * jQuery JavaScript Library v1.9.1
3 * http://jquery.com/
4 *
5 * Includes Sizzle.js
6 * http://sizzlejs.com/
7 *
8 * Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors
9 * Released under the MIT license
10 * http://jquery.org/license
11 *
12 * Date: 2013-2-4
13 */
14(function( window, undefined ) {
15
16// Can't do this because several apps including ASP.NET trace
17// the stack via arguments.caller.callee and Firefox dies if
18// you try to trace through "use strict" call chains. (#13335)
19// Support: Firefox 18+
20//"use strict";
21var
22	// The deferred used on DOM ready
23	readyList,
24
25	// A central reference to the root jQuery(document)
26	rootjQuery,
27
28	// Support: IE<9
29	// For `typeof node.method` instead of `node.method !== undefined`
30	core_strundefined = typeof undefined,
31
32	// Use the correct document accordingly with window argument (sandbox)
33	document = window.document,
34	location = window.location,
35
36	// Map over jQuery in case of overwrite
37	_jQuery = window.jQuery,
38
39	// Map over the $ in case of overwrite
40	_$ = window.$,
41
42	// [[Class]] -> type pairs
43	class2type = {},
44
45	// List of deleted data cache ids, so we can reuse them
46	core_deletedIds = [],
47
48	core_version = "1.9.1",
49
50	// Save a reference to some core methods
51	core_concat = core_deletedIds.concat,
52	core_push = core_deletedIds.push,
53	core_slice = core_deletedIds.slice,
54	core_indexOf = core_deletedIds.indexOf,
55	core_toString = class2type.toString,
56	core_hasOwn = class2type.hasOwnProperty,
57	core_trim = core_version.trim,
58
59	// Define a local copy of jQuery
60	jQuery = function( selector, context ) {
61		// The jQuery object is actually just the init constructor 'enhanced'
62		return new jQuery.fn.init( selector, context, rootjQuery );
63	},
64
65	// Used for matching numbers
66	core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
67
68	// Used for splitting on whitespace
69	core_rnotwhite = /\S+/g,
70
71	// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
72	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
73
74	// A simple way to check for HTML strings
75	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
76	// Strict HTML recognition (#11290: must start with <)
77	rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,
78
79	// Match a standalone tag
80	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
81
82	// JSON RegExp
83	rvalidchars = /^[\],:{}\s]*$/,
84	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
85	rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
86	rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,
87
88	// Matches dashed string for camelizing
89	rmsPrefix = /^-ms-/,
90	rdashAlpha = /-([\da-z])/gi,
91
92	// Used by jQuery.camelCase as callback to replace()
93	fcamelCase = function( all, letter ) {
94		return letter.toUpperCase();
95	},
96
97	// The ready event handler
98	completed = function( event ) {
99
100		// readyState === "complete" is good enough for us to call the dom ready in oldIE
101		if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {
102			detach();
103			jQuery.ready();
104		}
105	},
106	// Clean-up method for dom ready events
107	detach = function() {
108		if ( document.addEventListener ) {
109			document.removeEventListener( "DOMContentLoaded", completed, false );
110			window.removeEventListener( "load", completed, false );
111
112		} else {
113			document.detachEvent( "onreadystatechange", completed );
114			window.detachEvent( "onload", completed );
115		}
116	};
117
118jQuery.fn = jQuery.prototype = {
119	// The current version of jQuery being used
120	jquery: core_version,
121
122	constructor: jQuery,
123	init: function( selector, context, rootjQuery ) {
124		var match, elem;
125
126		// HANDLE: $(""), $(null), $(undefined), $(false)
127		if ( !selector ) {
128			return this;
129		}
130
131		// Handle HTML strings
132		if ( typeof selector === "string" ) {
133			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
134				// Assume that strings that start and end with <> are HTML and skip the regex check
135				match = [ null, selector, null ];
136
137			} else {
138				match = rquickExpr.exec( selector );
139			}
140
141			// Match html or make sure no context is specified for #id
142			if ( match && (match[1] || !context) ) {
143
144				// HANDLE: $(html) -> $(array)
145				if ( match[1] ) {
146					context = context instanceof jQuery ? context[0] : context;
147
148					// scripts is true for back-compat
149					jQuery.merge( this, jQuery.parseHTML(
150						match[1],
151						context && context.nodeType ? context.ownerDocument || context : document,
152						true
153					) );
154
155					// HANDLE: $(html, props)
156					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
157						for ( match in context ) {
158							// Properties of context are called as methods if possible
159							if ( jQuery.isFunction( this[ match ] ) ) {
160								this[ match ]( context[ match ] );
161
162							// ...and otherwise set as attributes
163							} else {
164								this.attr( match, context[ match ] );
165							}
166						}
167					}
168
169					return this;
170
171				// HANDLE: $(#id)
172				} else {
173					elem = document.getElementById( match[2] );
174
175					// Check parentNode to catch when Blackberry 4.6 returns
176					// nodes that are no longer in the document #6963
177					if ( elem && elem.parentNode ) {
178						// Handle the case where IE and Opera return items
179						// by name instead of ID
180						if ( elem.id !== match[2] ) {
181							return rootjQuery.find( selector );
182						}
183
184						// Otherwise, we inject the element directly into the jQuery object
185						this.length = 1;
186						this[0] = elem;
187					}
188
189					this.context = document;
190					this.selector = selector;
191					return this;
192				}
193
194			// HANDLE: $(expr, $(...))
195			} else if ( !context || context.jquery ) {
196				return ( context || rootjQuery ).find( selector );
197
198			// HANDLE: $(expr, context)
199			// (which is just equivalent to: $(context).find(expr)
200			} else {
201				return this.constructor( context ).find( selector );
202			}
203
204		// HANDLE: $(DOMElement)
205		} else if ( selector.nodeType ) {
206			this.context = this[0] = selector;
207			this.length = 1;
208			return this;
209
210		// HANDLE: $(function)
211		// Shortcut for document ready
212		} else if ( jQuery.isFunction( selector ) ) {
213			return rootjQuery.ready( selector );
214		}
215
216		if ( selector.selector !== undefined ) {
217			this.selector = selector.selector;
218			this.context = selector.context;
219		}
220
221		return jQuery.makeArray( selector, this );
222	},
223
224	// Start with an empty selector
225	selector: "",
226
227	// The default length of a jQuery object is 0
228	length: 0,
229
230	// The number of elements contained in the matched element set
231	size: function() {
232		return this.length;
233	},
234
235	toArray: function() {
236		return core_slice.call( this );
237	},
238
239	// Get the Nth element in the matched element set OR
240	// Get the whole matched element set as a clean array
241	get: function( num ) {
242		return num == null ?
243
244			// Return a 'clean' array
245			this.toArray() :
246
247			// Return just the object
248			( num < 0 ? this[ this.length + num ] : this[ num ] );
249	},
250
251	// Take an array of elements and push it onto the stack
252	// (returning the new matched element set)
253	pushStack: function( elems ) {
254
255		// Build a new jQuery matched element set
256		var ret = jQuery.merge( this.constructor(), elems );
257
258		// Add the old object onto the stack (as a reference)
259		ret.prevObject = this;
260		ret.context = this.context;
261
262		// Return the newly-formed element set
263		return ret;
264	},
265
266	// Execute a callback for every element in the matched set.
267	// (You can seed the arguments with an array of args, but this is
268	// only used internally.)
269	each: function( callback, args ) {
270		return jQuery.each( this, callback, args );
271	},
272
273	ready: function( fn ) {
274		// Add the callback
275		jQuery.ready.promise().done( fn );
276
277		return this;
278	},
279
280	slice: function() {
281		return this.pushStack( core_slice.apply( this, arguments ) );
282	},
283
284	first: function() {
285		return this.eq( 0 );
286	},
287
288	last: function() {
289		return this.eq( -1 );
290	},
291
292	eq: function( i ) {
293		var len = this.length,
294			j = +i + ( i < 0 ? len : 0 );
295		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
296	},
297
298	map: function( callback ) {
299		return this.pushStack( jQuery.map(this, function( elem, i ) {
300			return callback.call( elem, i, elem );
301		}));
302	},
303
304	end: function() {
305		return this.prevObject || this.constructor(null);
306	},
307
308	// For internal use only.
309	// Behaves like an Array's method, not like a jQuery method.
310	push: core_push,
311	sort: [].sort,
312	splice: [].splice
313};
314
315// Give the init function the jQuery prototype for later instantiation
316jQuery.fn.init.prototype = jQuery.fn;
317
318jQuery.extend = jQuery.fn.extend = function() {
319	var src, copyIsArray, copy, name, options, clone,
320		target = arguments[0] || {},
321		i = 1,
322		length = arguments.length,
323		deep = false;
324
325	// Handle a deep copy situation
326	if ( typeof target === "boolean" ) {
327		deep = target;
328		target = arguments[1] || {};
329		// skip the boolean and the target
330		i = 2;
331	}
332
333	// Handle case when target is a string or something (possible in deep copy)
334	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
335		target = {};
336	}
337
338	// extend jQuery itself if only one argument is passed
339	if ( length === i ) {
340		target = this;
341		--i;
342	}
343
344	for ( ; i < length; i++ ) {
345		// Only deal with non-null/undefined values
346		if ( (options = arguments[ i ]) != null ) {
347			// Extend the base object
348			for ( name in options ) {
349				src = target[ name ];
350				copy = options[ name ];
351
352				// Prevent never-ending loop
353				if ( target === copy ) {
354					continue;
355				}
356
357				// Recurse if we're merging plain objects or arrays
358				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
359					if ( copyIsArray ) {
360						copyIsArray = false;
361						clone = src && jQuery.isArray(src) ? src : [];
362
363					} else {
364						clone = src && jQuery.isPlainObject(src) ? src : {};
365					}
366
367					// Never move original objects, clone them
368					target[ name ] = jQuery.extend( deep, clone, copy );
369
370				// Don't bring in undefined values
371				} else if ( copy !== undefined ) {
372					target[ name ] = copy;
373				}
374			}
375		}
376	}
377
378	// Return the modified object
379	return target;
380};
381
382jQuery.extend({
383	noConflict: function( deep ) {
384		if ( window.$ === jQuery ) {
385			window.$ = _$;
386		}
387
388		if ( deep && window.jQuery === jQuery ) {
389			window.jQuery = _jQuery;
390		}
391
392		return jQuery;
393	},
394
395	// Is the DOM ready to be used? Set to true once it occurs.
396	isReady: false,
397
398	// A counter to track how many items to wait for before
399	// the ready event fires. See #6781
400	readyWait: 1,
401
402	// Hold (or release) the ready event
403	holdReady: function( hold ) {
404		if ( hold ) {
405			jQuery.readyWait++;
406		} else {
407			jQuery.ready( true );
408		}
409	},
410
411	// Handle when the DOM is ready
412	ready: function( wait ) {
413
414		// Abort if there are pending holds or we're already ready
415		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
416			return;
417		}
418
419		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
420		if ( !document.body ) {
421			return setTimeout( jQuery.ready );
422		}
423
424		// Remember that the DOM is ready
425		jQuery.isReady = true;
426
427		// If a normal DOM Ready event fired, decrement, and wait if need be
428		if ( wait !== true && --jQuery.readyWait > 0 ) {
429			return;
430		}
431
432		// If there are functions bound, to execute
433		readyList.resolveWith( document, [ jQuery ] );
434
435		// Trigger any bound ready events
436		if ( jQuery.fn.trigger ) {
437			jQuery( document ).trigger("ready").off("ready");
438		}
439	},
440
441	// See test/unit/core.js for details concerning isFunction.
442	// Since version 1.3, DOM methods and functions like alert
443	// aren't supported. They return false on IE (#2968).
444	isFunction: function( obj ) {
445		return jQuery.type(obj) === "function";
446	},
447
448	isArray: Array.isArray || function( obj ) {
449		return jQuery.type(obj) === "array";
450	},
451
452	isWindow: function( obj ) {
453		return obj != null && obj == obj.window;
454	},
455
456	isNumeric: function( obj ) {
457		return !isNaN( parseFloat(obj) ) && isFinite( obj );
458	},
459
460	type: function( obj ) {
461		if ( obj == null ) {
462			return String( obj );
463		}
464		return typeof obj === "object" || typeof obj === "function" ?
465			class2type[ core_toString.call(obj) ] || "object" :
466			typeof obj;
467	},
468
469	isPlainObject: function( obj ) {
470		// Must be an Object.
471		// Because of IE, we also have to check the presence of the constructor property.
472		// Make sure that DOM nodes and window objects don't pass through, as well
473		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
474			return false;
475		}
476
477		try {
478			// Not own constructor property must be Object
479			if ( obj.constructor &&
480				!core_hasOwn.call(obj, "constructor") &&
481				!core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
482				return false;
483			}
484		} catch ( e ) {
485			// IE8,9 Will throw exceptions on certain host objects #9897
486			return false;
487		}
488
489		// Own properties are enumerated firstly, so to speed up,
490		// if last one is own, then all properties are own.
491
492		var key;
493		for ( key in obj ) {}
494
495		return key === undefined || core_hasOwn.call( obj, key );
496	},
497
498	isEmptyObject: function( obj ) {
499		var name;
500		for ( name in obj ) {
501			return false;
502		}
503		return true;
504	},
505
506	error: function( msg ) {
507		throw new Error( msg );
508	},
509
510	// data: string of html
511	// context (optional): If specified, the fragment will be created in this context, defaults to document
512	// keepScripts (optional): If true, will include scripts passed in the html string
513	parseHTML: function( data, context, keepScripts ) {
514		if ( !data || typeof data !== "string" ) {
515			return null;
516		}
517		if ( typeof context === "boolean" ) {
518			keepScripts = context;
519			context = false;
520		}
521		context = context || document;
522
523		var parsed = rsingleTag.exec( data ),
524			scripts = !keepScripts && [];
525
526		// Single tag
527		if ( parsed ) {
528			return [ context.createElement( parsed[1] ) ];
529		}
530
531		parsed = jQuery.buildFragment( [ data ], context, scripts );
532		if ( scripts ) {
533			jQuery( scripts ).remove();
534		}
535		return jQuery.merge( [], parsed.childNodes );
536	},
537
538	parseJSON: function( data ) {
539		// Attempt to parse using the native JSON parser first
540		if ( window.JSON && window.JSON.parse ) {
541			return window.JSON.parse( data );
542		}
543
544		if ( data === null ) {
545			return data;
546		}
547
548		if ( typeof data === "string" ) {
549
550			// Make sure leading/trailing whitespace is removed (IE can't handle it)
551			data = jQuery.trim( data );
552
553			if ( data ) {
554				// Make sure the incoming data is actual JSON
555				// Logic borrowed from http://json.org/json2.js
556				if ( rvalidchars.test( data.replace( rvalidescape, "@" )
557					.replace( rvalidtokens, "]" )
558					.replace( rvalidbraces, "")) ) {
559
560					return ( new Function( "return " + data ) )();
561				}
562			}
563		}
564
565		jQuery.error( "Invalid JSON: " + data );
566	},
567
568	// Cross-browser xml parsing
569	parseXML: function( data ) {
570		var xml, tmp;
571		if ( !data || typeof data !== "string" ) {
572			return null;
573		}
574		try {
575			if ( window.DOMParser ) { // Standard
576				tmp = new DOMParser();
577				xml = tmp.parseFromString( data , "text/xml" );
578			} else { // IE
579				xml = new ActiveXObject( "Microsoft.XMLDOM" );
580				xml.async = "false";
581				xml.loadXML( data );
582			}
583		} catch( e ) {
584			xml = undefined;
585		}
586		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
587			jQuery.error( "Invalid XML: " + data );
588		}
589		return xml;
590	},
591
592	noop: function() {},
593
594	// Evaluates a script in a global context
595	// Workarounds based on findings by Jim Driscoll
596	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
597	globalEval: function( data ) {
598		if ( data && jQuery.trim( data ) ) {
599			// We use execScript on Internet Explorer
600			// We use an anonymous function so that context is window
601			// rather than jQuery in Firefox
602			( window.execScript || function( data ) {
603				window[ "eval" ].call( window, data );
604			} )( data );
605		}
606	},
607
608	// Convert dashed to camelCase; used by the css and data modules
609	// Microsoft forgot to hump their vendor prefix (#9572)
610	camelCase: function( string ) {
611		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
612	},
613
614	nodeName: function( elem, name ) {
615		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
616	},
617
618	// args is for internal usage only
619	each: function( obj, callback, args ) {
620		var value,
621			i = 0,
622			length = obj.length,
623			isArray = isArraylike( obj );
624
625		if ( args ) {
626			if ( isArray ) {
627				for ( ; i < length; i++ ) {
628					value = callback.apply( obj[ i ], args );
629
630					if ( value === false ) {
631						break;
632					}
633				}
634			} else {
635				for ( i in obj ) {
636					value = callback.apply( obj[ i ], args );
637
638					if ( value === false ) {
639						break;
640					}
641				}
642			}
643
644		// A special, fast, case for the most common use of each
645		} else {
646			if ( isArray ) {
647				for ( ; i < length; i++ ) {
648					value = callback.call( obj[ i ], i, obj[ i ] );
649
650					if ( value === false ) {
651						break;
652					}
653				}
654			} else {
655				for ( i in obj ) {
656					value = callback.call( obj[ i ], i, obj[ i ] );
657
658					if ( value === false ) {
659						break;
660					}
661				}
662			}
663		}
664
665		return obj;
666	},
667
668	// Use native String.trim function wherever possible
669	trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
670		function( text ) {
671			return text == null ?
672				"" :
673				core_trim.call( text );
674		} :
675
676		// Otherwise use our own trimming functionality
677		function( text ) {
678			return text == null ?
679				"" :
680				( text + "" ).replace( rtrim, "" );
681		},
682
683	// results is for internal usage only
684	makeArray: function( arr, results ) {
685		var ret = results || [];
686
687		if ( arr != null ) {
688			if ( isArraylike( Object(arr) ) ) {
689				jQuery.merge( ret,
690					typeof arr === "string" ?
691					[ arr ] : arr
692				);
693			} else {
694				core_push.call( ret, arr );
695			}
696		}
697
698		return ret;
699	},
700
701	inArray: function( elem, arr, i ) {
702		var len;
703
704		if ( arr ) {
705			if ( core_indexOf ) {
706				return core_indexOf.call( arr, elem, i );
707			}
708
709			len = arr.length;
710			i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
711
712			for ( ; i < len; i++ ) {
713				// Skip accessing in sparse arrays
714				if ( i in arr && arr[ i ] === elem ) {
715					return i;
716				}
717			}
718		}
719
720		return -1;
721	},
722
723	merge: function( first, second ) {
724		var l = second.length,
725			i = first.length,
726			j = 0;
727
728		if ( typeof l === "number" ) {
729			for ( ; j < l; j++ ) {
730				first[ i++ ] = second[ j ];
731			}
732		} else {
733			while ( second[j] !== undefined ) {
734				first[ i++ ] = second[ j++ ];
735			}
736		}
737
738		first.length = i;
739
740		return first;
741	},
742
743	grep: function( elems, callback, inv ) {
744		var retVal,
745			ret = [],
746			i = 0,
747			length = elems.length;
748		inv = !!inv;
749
750		// Go through the array, only saving the items
751		// that pass the validator function
752		for ( ; i < length; i++ ) {
753			retVal = !!callback( elems[ i ], i );
754			if ( inv !== retVal ) {
755				ret.push( elems[ i ] );
756			}
757		}
758
759		return ret;
760	},
761
762	// arg is for internal usage only
763	map: function( elems, callback, arg ) {
764		var value,
765			i = 0,
766			length = elems.length,
767			isArray = isArraylike( elems ),
768			ret = [];
769
770		// Go through the array, translating each of the items to their
771		if ( isArray ) {
772			for ( ; i < length; i++ ) {
773				value = callback( elems[ i ], i, arg );
774
775				if ( value != null ) {
776					ret[ ret.length ] = value;
777				}
778			}
779
780		// Go through every key on the object,
781		} else {
782			for ( i in elems ) {
783				value = callback( elems[ i ], i, arg );
784
785				if ( value != null ) {
786					ret[ ret.length ] = value;
787				}
788			}
789		}
790
791		// Flatten any nested arrays
792		return core_concat.apply( [], ret );
793	},
794
795	// A global GUID counter for objects
796	guid: 1,
797
798	// Bind a function to a context, optionally partially applying any
799	// arguments.
800	proxy: function( fn, context ) {
801		var args, proxy, tmp;
802
803		if ( typeof context === "string" ) {
804			tmp = fn[ context ];
805			context = fn;
806			fn = tmp;
807		}
808
809		// Quick check to determine if target is callable, in the spec
810		// this throws a TypeError, but we will just return undefined.
811		if ( !jQuery.isFunction( fn ) ) {
812			return undefined;
813		}
814
815		// Simulated bind
816		args = core_slice.call( arguments, 2 );
817		proxy = function() {
818			return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) );
819		};
820
821		// Set the guid of unique handler to the same of original handler, so it can be removed
822		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
823
824		return proxy;
825	},
826
827	// Multifunctional method to get and set values of a collection
828	// The value/s can optionally be executed if it's a function
829	access: function( elems, fn, key, value, chainable, emptyGet, raw ) {
830		var i = 0,
831			length = elems.length,
832			bulk = key == null;
833
834		// Sets many values
835		if ( jQuery.type( key ) === "object" ) {
836			chainable = true;
837			for ( i in key ) {
838				jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
839			}
840
841		// Sets one value
842		} else if ( value !== undefined ) {
843			chainable = true;
844
845			if ( !jQuery.isFunction( value ) ) {
846				raw = true;
847			}
848
849			if ( bulk ) {
850				// Bulk operations run against the entire set
851				if ( raw ) {
852					fn.call( elems, value );
853					fn = null;
854
855				// ...except when executing function values
856				} else {
857					bulk = fn;
858					fn = function( elem, key, value ) {
859						return bulk.call( jQuery( elem ), value );
860					};
861				}
862			}
863
864			if ( fn ) {
865				for ( ; i < length; i++ ) {
866					fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
867				}
868			}
869		}
870
871		return chainable ?
872			elems :
873
874			// Gets
875			bulk ?
876				fn.call( elems ) :
877				length ? fn( elems[0], key ) : emptyGet;
878	},
879
880	now: function() {
881		return ( new Date() ).getTime();
882	}
883});
884
885jQuery.ready.promise = function( obj ) {
886	if ( !readyList ) {
887
888		readyList = jQuery.Deferred();
889
890		// Catch cases where $(document).ready() is called after the browser event has already occurred.
891		// we once tried to use readyState "interactive" here, but it caused issues like the one
892		// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
893		if ( document.readyState === "complete" ) {
894			// Handle it asynchronously to allow scripts the opportunity to delay ready
895			setTimeout( jQuery.ready );
896
897		// Standards-based browsers support DOMContentLoaded
898		} else if ( document.addEventListener ) {
899			// Use the handy event callback
900			document.addEventListener( "DOMContentLoaded", completed, false );
901
902			// A fallback to window.onload, that will always work
903			window.addEventListener( "load", completed, false );
904
905		// If IE event model is used
906		} else {
907			// Ensure firing before onload, maybe late but safe also for iframes
908			document.attachEvent( "onreadystatechange", completed );
909
910			// A fallback to window.onload, that will always work
911			window.attachEvent( "onload", completed );
912
913			// If IE and not a frame
914			// continually check to see if the document is ready
915			var top = false;
916
917			try {
918				top = window.frameElement == null && document.documentElement;
919			} catch(e) {}
920
921			if ( top && top.doScroll ) {
922				(function doScrollCheck() {
923					if ( !jQuery.isReady ) {
924
925						try {
926							// Use the trick by Diego Perini
927							// http://javascript.nwbox.com/IEContentLoaded/
928							top.doScroll("left");
929						} catch(e) {
930							return setTimeout( doScrollCheck, 50 );
931						}
932
933						// detach all dom ready events
934						detach();
935
936						// and execute any waiting functions
937						jQuery.ready();
938					}
939				})();
940			}
941		}
942	}
943	return readyList.promise( obj );
944};
945
946// Populate the class2type map
947jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
948	class2type[ "[object " + name + "]" ] = name.toLowerCase();
949});
950
951function isArraylike( obj ) {
952	var length = obj.length,
953		type = jQuery.type( obj );
954
955	if ( jQuery.isWindow( obj ) ) {
956		return false;
957	}
958
959	if ( obj.nodeType === 1 && length ) {
960		return true;
961	}
962
963	return type === "array" || type !== "function" &&
964		( length === 0 ||
965		typeof length === "number" && length > 0 && ( length - 1 ) in obj );
966}
967
968// All jQuery objects should point back to these
969rootjQuery = jQuery(document);
970// String to Object options format cache
971var optionsCache = {};
972
973// Convert String-formatted options into Object-formatted ones and store in cache
974function createOptions( options ) {
975	var object = optionsCache[ options ] = {};
976	jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {
977		object[ flag ] = true;
978	});
979	return object;
980}
981
982/*
983 * Create a callback list using the following parameters:
984 *
985 *	options: an optional list of space-separated options that will change how
986 *			the callback list behaves or a more traditional option object
987 *
988 * By default a callback list will act like an event callback list and can be
989 * "fired" multiple times.
990 *
991 * Possible options:
992 *
993 *	once:			will ensure the callback list can only be fired once (like a Deferred)
994 *
995 *	memory:			will keep track of previous values and will call any callback added
996 *					after the list has been fired right away with the latest "memorized"
997 *					values (like a Deferred)
998 *
999 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
1000 *
1001 *	stopOnFalse:	interrupt callings when a callback returns false
1002 *
1003 */
1004jQuery.Callbacks = function( options ) {
1005
1006	// Convert options from String-formatted to Object-formatted if needed
1007	// (we check in cache first)
1008	options = typeof options === "string" ?
1009		( optionsCache[ options ] || createOptions( options ) ) :
1010		jQuery.extend( {}, options );
1011
1012	var // Flag to know if list is currently firing
1013		firing,
1014		// Last fire value (for non-forgettable lists)
1015		memory,
1016		// Flag to know if list was already fired
1017		fired,
1018		// End of the loop when firing
1019		firingLength,
1020		// Index of currently firing callback (modified by remove if needed)
1021		firingIndex,
1022		// First callback to fire (used internally by add and fireWith)
1023		firingStart,
1024		// Actual callback list
1025		list = [],
1026		// Stack of fire calls for repeatable lists
1027		stack = !options.once && [],
1028		// Fire callbacks
1029		fire = function( data ) {
1030			memory = options.memory && data;
1031			fired = true;
1032			firingIndex = firingStart || 0;
1033			firingStart = 0;
1034			firingLength = list.length;
1035			firing = true;
1036			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
1037				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
1038					memory = false; // To prevent further calls using add
1039					break;
1040				}
1041			}
1042			firing = false;
1043			if ( list ) {
1044				if ( stack ) {
1045					if ( stack.length ) {
1046						fire( stack.shift() );
1047					}
1048				} else if ( memory ) {
1049					list = [];
1050				} else {
1051					self.disable();
1052				}
1053			}
1054		},
1055		// Actual Callbacks object
1056		self = {
1057			// Add a callback or a collection of callbacks to the list
1058			add: function() {
1059				if ( list ) {
1060					// First, we save the current length
1061					var start = list.length;
1062					(function add( args ) {
1063						jQuery.each( args, function( _, arg ) {
1064							var type = jQuery.type( arg );
1065							if ( type === "function" ) {
1066								if ( !options.unique || !self.has( arg ) ) {
1067									list.push( arg );
1068								}
1069							} else if ( arg && arg.length && type !== "string" ) {
1070								// Inspect recursively
1071								add( arg );
1072							}
1073						});
1074					})( arguments );
1075					// Do we need to add the callbacks to the
1076					// current firing batch?
1077					if ( firing ) {
1078						firingLength = list.length;
1079					// With memory, if we're not firing then
1080					// we should call right away
1081					} else if ( memory ) {
1082						firingStart = start;
1083						fire( memory );
1084					}
1085				}
1086				return this;
1087			},
1088			// Remove a callback from the list
1089			remove: function() {
1090				if ( list ) {
1091					jQuery.each( arguments, function( _, arg ) {
1092						var index;
1093						while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
1094							list.splice( index, 1 );
1095							// Handle firing indexes
1096							if ( firing ) {
1097								if ( index <= firingLength ) {
1098									firingLength--;
1099								}
1100								if ( index <= firingIndex ) {
1101									firingIndex--;
1102								}
1103							}
1104						}
1105					});
1106				}
1107				return this;
1108			},
1109			// Check if a given callback is in the list.
1110			// If no argument is given, return whether or not list has callbacks attached.
1111			has: function( fn ) {
1112				return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
1113			},
1114			// Remove all callbacks from the list
1115			empty: function() {
1116				list = [];
1117				return this;
1118			},
1119			// Have the list do nothing anymore
1120			disable: function() {
1121				list = stack = memory = undefined;
1122				return this;
1123			},
1124			// Is it disabled?
1125			disabled: function() {
1126				return !list;
1127			},
1128			// Lock the list in its current state
1129			lock: function() {
1130				stack = undefined;
1131				if ( !memory ) {
1132					self.disable();
1133				}
1134				return this;
1135			},
1136			// Is it locked?
1137			locked: function() {
1138				return !stack;
1139			},
1140			// Call all callbacks with the given context and arguments
1141			fireWith: function( context, args ) {
1142				args = args || [];
1143				args = [ context, args.slice ? args.slice() : args ];
1144				if ( list && ( !fired || stack ) ) {
1145					if ( firing ) {
1146						stack.push( args );
1147					} else {
1148						fire( args );
1149					}
1150				}
1151				return this;
1152			},
1153			// Call all the callbacks with the given arguments
1154			fire: function() {
1155				self.fireWith( this, arguments );
1156				return this;
1157			},
1158			// To know if the callbacks have already been called at least once
1159			fired: function() {
1160				return !!fired;
1161			}
1162		};
1163
1164	return self;
1165};
1166jQuery.extend({
1167
1168	Deferred: function( func ) {
1169		var tuples = [
1170				// action, add listener, listener list, final state
1171				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
1172				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
1173				[ "notify", "progress", jQuery.Callbacks("memory") ]
1174			],
1175			state = "pending",
1176			promise = {
1177				state: function() {
1178					return state;
1179				},
1180				always: function() {
1181					deferred.done( arguments ).fail( arguments );
1182					return this;
1183				},
1184				then: function( /* fnDone, fnFail, fnProgress */ ) {
1185					var fns = arguments;
1186					return jQuery.Deferred(function( newDefer ) {
1187						jQuery.each( tuples, function( i, tuple ) {
1188							var action = tuple[ 0 ],
1189								fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
1190							// deferred[ done | fail | progress ] for forwarding actions to newDefer
1191							deferred[ tuple[1] ](function() {
1192								var returned = fn && fn.apply( this, arguments );
1193								if ( returned && jQuery.isFunction( returned.promise ) ) {
1194									returned.promise()
1195										.done( newDefer.resolve )
1196										.fail( newDefer.reject )
1197										.progress( newDefer.notify );
1198								} else {
1199									newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
1200								}
1201							});

1202						});
1203						fns = null;
1204					}).promise();
1205				},
1206				// Get a promise for this deferred
1207				// If obj is provided, the promise aspect is added to the object
1208				promise: function( obj ) {
1209					return obj != null ? jQuery.extend( obj, promise ) : promise;
1210				}
1211			},
1212			deferred = {};
1213
1214		// Keep pipe for back-compat
1215		promise.pipe = promise.then;
1216
1217		// Add list-specific methods
1218		jQuery.each( tuples, function( i, tuple ) {
1219			var list = tuple[ 2 ],
1220				stateString = tuple[ 3 ];
1221
1222			// promise[ done | fail | progress ] = list.add
1223			promise[ tuple[1] ] = list.add;
1224
1225			// Handle state
1226			if ( stateString ) {
1227				list.add(function() {
1228					// state = [ resolved | rejected ]
1229					state = stateString;
1230
1231				// [ reject_list | resolve_list ].disable; progress_list.lock
1232				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
1233			}
1234
1235			// deferred[ resolve | reject | notify ]
1236			deferred[ tuple[0] ] = function() {
1237				deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
1238				return this;
1239			};
1240			deferred[ tuple[0] + "With" ] = list.fireWith;
1241		});
1242
1243		// Make the deferred a promise
1244		promise.promise( deferred );
1245
1246		// Call given func if any
1247		if ( func ) {
1248			func.call( deferred, deferred );
1249		}
1250
1251		// All done!
1252		return deferred;
1253	},
1254
1255	// Deferred helper
1256	when: function( subordinate /* , ..., subordinateN */ ) {
1257		var i = 0,
1258			resolveValues = core_slice.call( arguments ),
1259			length = resolveValues.length,
1260
1261			// the count of uncompleted subordinates
1262			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
1263
1264			// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
1265			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
1266
1267			// Update function for both resolve and progress values
1268			updateFunc = function( i, contexts, values ) {
1269				return function( value ) {
1270					contexts[ i ] = this;
1271					values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
1272					if( values === progressValues ) {
1273						deferred.notifyWith( contexts, values );
1274					} else if ( !( --remaining ) ) {
1275						deferred.resolveWith( contexts, values );
1276					}
1277				};
1278			},
1279
1280			progressValues, progressContexts, resolveContexts;
1281
1282		// add listeners to Deferred subordinates; treat others as resolved
1283		if ( length > 1 ) {
1284			progressValues = new Array( length );
1285			progressContexts = new Array( length );
1286			resolveContexts = new Array( length );
1287			for ( ; i < length; i++ ) {
1288				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
1289					resolveValues[ i ].promise()
1290						.done( updateFunc( i, resolveContexts, resolveValues ) )
1291						.fail( deferred.reject )
1292						.progress( updateFunc( i, progressContexts, progressValues ) );
1293				} else {
1294					--remaining;
1295				}
1296			}
1297		}
1298
1299		// if we're not waiting on anything, resolve the master
1300		if ( !remaining ) {
1301			deferred.resolveWith( resolveContexts, resolveValues );
1302		}
1303
1304		return deferred.promise();
1305	}
1306});
1307jQuery.support = (function() {
1308
1309	var support, all, a,
1310		input, select, fragment,
1311		opt, eventName, isSupported, i,
1312		div = document.createElement("div");
1313
1314	// Setup
1315	div.setAttribute( "className", "t" );
1316	div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
1317
1318	// Support tests won't run in some limited or non-browser environments
1319	all = div.getElementsByTagName("*");
1320	a = div.getElementsByTagName("a")[ 0 ];
1321	if ( !all || !a || !all.length ) {
1322		return {};
1323	}
1324
1325	// First batch of tests
1326	select = document.createElement("select");
1327	opt = select.appendChild( document.createElement("option") );
1328	input = div.getElementsByTagName("input")[ 0 ];
1329
1330	a.style.cssText = "top:1px;float:left;opacity:.5";
1331	support = {
1332		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1333		getSetAttribute: div.className !== "t",
1334
1335		// IE strips leading whitespace when .innerHTML is used
1336		leadingWhitespace: div.firstChild.nodeType === 3,
1337
1338		// Make sure that tbody elements aren't automatically inserted
1339		// IE will insert them into empty tables
1340		tbody: !div.getElementsByTagName("tbody").length,
1341
1342		// Make sure that link elements get serialized correctly by innerHTML
1343		// This requires a wrapper element in IE
1344		htmlSerialize: !!div.getElementsByTagName("link").length,
1345
1346		// Get the style information from getAttribute
1347		// (IE uses .cssText instead)
1348		style: /top/.test( a.getAttribute("style") ),
1349
1350		// Make sure that URLs aren't manipulated
1351		// (IE normalizes it by default)
1352		hrefNormalized: a.getAttribute("href") === "/a",
1353
1354		// Make sure that element opacity exists
1355		// (IE uses filter instead)
1356		// Use a regex to work around a WebKit issue. See #5145
1357		opacity: /^0.5/.test( a.style.opacity ),
1358
1359		// Verify style float existence
1360		// (IE uses styleFloat instead of cssFloat)
1361
1362		cssFloat: !!a.style.cssFloat,
1363
1364		// Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
1365		checkOn: !!input.value,
1366
1367		// Make sure that a selected-by-default option has a working selected property.
1368		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1369		optSelected: opt.selected,
1370
1371		// Tests for enctype support on a form (#6743)
1372		enctype: !!document.createElement("form").enctype,
1373
1374		// Makes sure cloning an html5 element does not cause problems
1375		// Where outerHTML is undefined, this still works
1376		html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
1377
1378		// jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
1379		boxModel: document.compatMode === "CSS1Compat",
1380
1381		// Will be defined later
1382		deleteExpando: true,
1383		noCloneEvent: true,
1384		inlineBlockNeedsLayout: false,
1385		shrinkWrapBlocks: false,
1386		reliableMarginRight: true,
1387		boxSizingReliable: true,
1388		pixelPosition: false
1389	};
1390
1391	// Make sure checked status is properly cloned
1392	input.checked = true;
1393	support.noCloneChecked = input.cloneNode( true ).checked;
1394
1395	// Make sure that the options inside disabled selects aren't marked as disabled
1396	// (WebKit marks them as disabled)
1397	select.disabled = true;
1398	support.optDisabled = !opt.disabled;
1399
1400	// Support: IE<9

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

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

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

2570			return ret && ( name === "id" || name === "name" || name === "coords" ? ret.value !== "" : ret.specified ) ?
2571				ret.value :
2572				undefined;
2573		},
2574		set: function( elem, value, name ) {
2575			// Set the existing or create a new attribute node
2576			var ret = elem.getAttributeNode( name );
2577			if ( !ret ) {
2578				elem.setAttributeNode(
2579					(ret = elem.ownerDocument.createAttribute( name ))
2580				);
2581			}
2582
2583			ret.value = value += "";
2584
2585			// Break association with cloned elements by also using setAttribute (#9646)
2586			return name === "value" || value === elem.getAttribute( name ) ?
2587				value :
2588				undefined;
2589		}
2590	};
2591
2592	// Set contenteditable to false on removals(#10429)
2593	// Setting to empty string throws an error as an invalid value
2594	jQuery.attrHooks.contenteditable = {
2595		get: nodeHook.get,
2596		set: function( elem, value, name ) {
2597			nodeHook.set( elem, value === "" ? false : value, name );
2598		}
2599	};
2600
2601	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
2602	// This is for removals
2603	jQuery.each([ "width", "height" ], function( i, name ) {
2604		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2605			set: function( elem, value ) {
2606				if ( value === "" ) {
2607					elem.setAttribute( name, "auto" );
2608					return value;
2609				}
2610			}
2611		});
2612	});
2613}
2614
2615
2616// Some attributes require a special call on IE
2617// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2618if ( !jQuery.support.hrefNormalized ) {
2619	jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
2620		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2621			get: function( elem ) {
2622				var ret = elem.getAttribute( name, 2 );
2623				return ret == null ? undefined : ret;
2624			}
2625		});
2626	});
2627
2628	// href/src property should get the full normalized URL (#10299/#12915)
2629	jQuery.each([ "href", "src" ], function( i, name ) {
2630		jQuery.propHooks[ name ] = {
2631			get: function( elem ) {
2632				return elem.getAttribute( name, 4 );
2633			}
2634		};
2635	});
2636}
2637
2638if ( !jQuery.support.style ) {
2639	jQuery.attrHooks.style = {
2640		get: function( elem ) {
2641			// Return undefined in the case of empty string
2642			// Note: IE uppercases css property names, but if we were to .toLowerCase()
2643			// .cssText, that would destroy case senstitivity in URL's, like in "background"
2644			return elem.style.cssText || undefined;
2645		},
2646		set: function( elem, value ) {
2647			return ( elem.style.cssText = value + "" );
2648		}
2649	};
2650}
2651
2652// Safari mis-reports the default selected property of an option
2653// Accessing the parent's selectedIndex property fixes it
2654if ( !jQuery.support.optSelected ) {
2655	jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
2656		get: function( elem ) {
2657			var parent = elem.parentNode;
2658
2659			if ( parent ) {
2660				parent.selectedIndex;
2661
2662				// Make sure that it also works with optgroups, see #5701
2663				if ( parent.parentNode ) {
2664					parent.parentNode.selectedIndex;
2665				}
2666			}
2667			return null;
2668		}
2669	});
2670}
2671
2672// IE6/7 call enctype encoding
2673if ( !jQuery.support.enctype ) {
2674	jQuery.propFix.enctype = "encoding";
2675}
2676
2677// Radios and checkboxes getter/setter
2678if ( !jQuery.support.checkOn ) {
2679	jQuery.each([ "radio", "checkbox" ], function() {
2680		jQuery.valHooks[ this ] = {
2681			get: function( elem ) {
2682				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2683				return elem.getAttribute("value") === null ? "on" : elem.value;
2684			}
2685		};
2686	});
2687}
2688jQuery.each([ "radio", "checkbox" ], function() {
2689	jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2690		set: function( elem, value ) {
2691			if ( jQuery.isArray( value ) ) {
2692				return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
2693			}
2694		}
2695	});
2696});
2697var rformElems = /^(?:input|select|textarea)$/i,
2698	rkeyEvent = /^key/,
2699	rmouseEvent = /^(?:mouse|contextmenu)|click/,
2700	rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
2701	rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
2702
2703function returnTrue() {
2704	return true;
2705}
2706
2707function returnFalse() {
2708	return false;
2709}
2710
2711/*
2712 * Helper functions for managing events -- not part of the public interface.
2713 * Props to Dean Edwards' addEvent library for many of the ideas.
2714 */
2715jQuery.event = {
2716
2717	global: {},
2718
2719	add: function( elem, types, handler, data, selector ) {
2720		var tmp, events, t, handleObjIn,
2721			special, eventHandle, handleObj,
2722			handlers, type, namespaces, origType,
2723			elemData = jQuery._data( elem );
2724
2725		// Don't attach events to noData or text/comment nodes (but allow plain objects)
2726		if ( !elemData ) {
2727			return;
2728		}
2729
2730		// Caller can pass in an object of custom data in lieu of the handler
2731		if ( handler.handler ) {
2732			handleObjIn = handler;
2733			handler = handleObjIn.handler;
2734			selector = handleObjIn.selector;
2735		}
2736
2737		// Make sure that the handler has a unique ID, used to find/remove it later
2738		if ( !handler.guid ) {
2739			handler.guid = jQuery.guid++;
2740		}
2741
2742		// Init the element's event structure and main handler, if this is the first
2743		if ( !(events = elemData.events) ) {
2744			events = elemData.events = {};
2745		}
2746		if ( !(eventHandle = elemData.handle) ) {
2747			eventHandle = elemData.handle = function( e ) {
2748				// Discard the second event of a jQuery.event.trigger() and
2749				// when an event is called after a page has unloaded
2750				return typeof jQuery !== core_strundefined && (!e || jQuery.event.triggered !== e.type) ?
2751					jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
2752					undefined;
2753			};
2754			// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
2755			eventHandle.elem = elem;
2756		}
2757
2758		// Handle multiple events separated by a space
2759		// jQuery(...).bind("mouseover mouseout", fn);
2760		types = ( types || "" ).match( core_rnotwhite ) || [""];
2761		t = types.length;
2762		while ( t-- ) {
2763			tmp = rtypenamespace.exec( types[t] ) || [];
2764			type = origType = tmp[1];
2765			namespaces = ( tmp[2] || "" ).split( "." ).sort();
2766
2767			// If event changes its type, use the special event handlers for the changed type
2768			special = jQuery.event.special[ type ] || {};
2769
2770			// If selector defined, determine special event api type, otherwise given type
2771			type = ( selector ? special.delegateType : special.bindType ) || type;
2772
2773			// Update special based on newly reset type
2774			special = jQuery.event.special[ type ] || {};
2775
2776			// handleObj is passed to all event handlers
2777			handleObj = jQuery.extend({
2778				type: type,
2779				origType: origType,
2780				data: data,
2781				handler: handler,
2782				guid: handler.guid,
2783				selector: selector,
2784				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
2785				namespace: namespaces.join(".")
2786			}, handleObjIn );
2787
2788			// Init the event handler queue if we're the first
2789			if ( !(handlers = events[ type ]) ) {
2790				handlers = events[ type ] = [];
2791				handlers.delegateCount = 0;
2792
2793				// Only use addEventListener/attachEvent if the special events handler returns false
2794				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2795					// Bind the global event handler to the element
2796					if ( elem.addEventListener ) {
2797						elem.addEventListener( type, eventHandle, false );
2798
2799					} else if ( elem.attachEvent ) {
2800						elem.attachEvent( "on" + type, eventHandle );
2801					}
2802				}
2803			}
2804
2805			if ( special.add ) {
2806				special.add.call( elem, handleObj );
2807
2808				if ( !handleObj.handler.guid ) {
2809					handleObj.handler.guid = handler.guid;
2810				}
2811			}
2812
2813			// Add to the element's handler list, delegates in front
2814			if ( selector ) {
2815				handlers.splice( handlers.delegateCount++, 0, handleObj );
2816			} else {
2817				handlers.push( handleObj );
2818			}
2819
2820			// Keep track of which events have ever been used, for event optimization
2821			jQuery.event.global[ type ] = true;
2822		}
2823
2824		// Nullify elem to prevent memory leaks in IE
2825		elem = null;
2826	},
2827
2828	// Detach an event or set of events from an element
2829	remove: function( elem, types, handler, selector, mappedTypes ) {
2830		var j, handleObj, tmp,
2831			origCount, t, events,
2832			special, handlers, type,
2833			namespaces, origType,
2834			elemData = jQuery.hasData( elem ) && jQuery._data( elem );
2835
2836		if ( !elemData || !(events = elemData.events) ) {
2837			return;
2838		}
2839
2840		// Once for each type.namespace in types; type may be omitted
2841		types = ( types || "" ).match( core_rnotwhite ) || [""];
2842		t = types.length;
2843		while ( t-- ) {
2844			tmp = rtypenamespace.exec( types[t] ) || [];
2845			type = origType = tmp[1];
2846			namespaces = ( tmp[2] || "" ).split( "." ).sort();
2847
2848			// Unbind all events (on this namespace, if provided) for the element
2849			if ( !type ) {
2850				for ( type in events ) {
2851					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
2852				}
2853				continue;
2854			}
2855
2856			special = jQuery.event.special[ type ] || {};
2857			type = ( selector ? special.delegateType : special.bindType ) || type;
2858			handlers = events[ type ] || [];
2859			tmp = tmp[2] && new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" );
2860
2861			// Remove matching events
2862			origCount = j = handlers.length;
2863			while ( j-- ) {
2864				handleObj = handlers[ j ];
2865
2866				if ( ( mappedTypes || origType === handleObj.origType ) &&
2867					( !handler || handler.guid === handleObj.guid ) &&
2868					( !tmp || tmp.test( handleObj.namespace ) ) &&
2869					( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
2870					handlers.splice( j, 1 );
2871
2872					if ( handleObj.selector ) {
2873						handlers.delegateCount--;
2874					}
2875					if ( special.remove ) {
2876						special.remove.call( elem, handleObj );
2877					}
2878				}
2879			}
2880
2881			// Remove generic event handler if we removed something and no more handlers exist
2882			// (avoids potential for endless recursion during removal of special event handlers)
2883			if ( origCount && !handlers.length ) {
2884				if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
2885					jQuery.removeEvent( elem, type, elemData.handle );
2886				}
2887
2888
2889				delete events[ type ];
2890			}
2891		}
2892
2893		// Remove the expando if it's no longer used
2894		if ( jQuery.isEmptyObject( events ) ) {
2895			delete elemData.handle;
2896
2897			// removeData also checks for emptiness and clears the expando if empty
2898			// so use it instead of delete
2899			jQuery._removeData( elem, "events" );
2900		}
2901	},
2902
2903	trigger: function( event, data, elem, onlyHandlers ) {
2904		var handle, ontype, cur,
2905			bubbleType, special, tmp, i,
2906			eventPath = [ elem || document ],
2907			type = core_hasOwn.call( event, "type" ) ? event.type : event,
2908			namespaces = core_hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : [];
2909
2910		cur = tmp = elem = elem || document;
2911
2912		// Don't do events on text and comment nodes
2913		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2914			return;
2915		}
2916
2917		// focus/blur morphs to focusin/out; ensure we're not firing them right now
2918		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
2919			return;
2920		}
2921
2922		if ( type.indexOf(".") >= 0 ) {
2923			// Namespaced trigger; create a regexp to match event type in handle()
2924			namespaces = type.split(".");
2925			type = namespaces.shift();
2926			namespaces.sort();
2927		}
2928		ontype = type.indexOf(":") < 0 && "on" + type;
2929
2930		// Caller can pass in a jQuery.Event object, Object, or just an event type string
2931		event = event[ jQuery.expando ] ?
2932			event :
2933			new jQuery.Event( type, typeof event === "object" && event );
2934
2935		event.isTrigger = true;
2936		event.namespace = namespaces.join(".");
2937		event.namespace_re = event.namespace ?
2938			new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) :
2939			null;
2940
2941		// Clean up the event in case it is being reused
2942		event.result = undefined;
2943		if ( !event.target ) {
2944			event.target = elem;
2945		}
2946
2947		// Clone any incoming data and prepend the event, creating the handler arg list
2948		data = data == null ?
2949			[ event ] :
2950			jQuery.makeArray( data, [ event ] );
2951
2952		// Allow special events to draw outside the lines
2953		special = jQuery.event.special[ type ] || {};
2954		if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
2955			return;
2956		}
2957
2958		// Determine event propagation path in advance, per W3C events spec (#9951)
2959		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
2960		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
2961
2962			bubbleType = special.delegateType || type;
2963			if ( !rfocusMorph.test( bubbleType + type ) ) {
2964				cur = cur.parentNode;
2965			}
2966			for ( ; cur; cur = cur.parentNode ) {
2967				eventPath.push( cur );
2968				tmp = cur;
2969			}
2970
2971			// Only add window if we got to document (e.g., not plain obj or detached DOM)
2972			if ( tmp === (elem.ownerDocument || document) ) {
2973				eventPath.push( tmp.defaultView || tmp.parentWindow || window );
2974			}
2975		}
2976
2977		// Fire handlers on the event path
2978		i = 0;
2979		while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) {
2980
2981			event.type = i > 1 ?
2982				bubbleType :
2983				special.bindType || type;
2984
2985			// jQuery handler
2986			handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
2987			if ( handle ) {
2988				handle.apply( cur, data );
2989			}
2990
2991			// Native handler
2992			handle = ontype && cur[ ontype ];
2993			if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) {
2994				event.preventDefault();
2995			}
2996		}
2997		event.type = type;
2998
2999		// If nobody prevented the default action, do it now
3000		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
3001
3002			if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
3003				!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
3004
3005				// Call a native DOM method on the target with the same name name as the event.
3006				// Can't use an .isFunction() check here because IE6/7 fails that test.
3007				// Don't do default actions on window, that's where global variables be (#6170)
3008				if ( ontype && elem[ type ] && !jQuery.isWindow( elem ) ) {
3009
3010					// Don't re-trigger an onFOO event when we call its FOO() method
3011					tmp = elem[ ontype ];
3012
3013					if ( tmp ) {
3014						elem[ ontype ] = null;
3015					}
3016
3017					// Prevent re-triggering of the same event, since we already bubbled it above
3018					jQuery.event.triggered = type;
3019					try {
3020						elem[ type ]();
3021					} catch ( e ) {
3022						// IE<9 dies on focus/blur to hidden element (#1486,#12518)
3023						// only reproducible on winXP IE8 native, not IE9 in IE8 mode
3024					}
3025					jQuery.event.triggered = undefined;
3026
3027					if ( tmp ) {
3028						elem[ ontype ] = tmp;
3029					}
3030				}
3031			}
3032		}
3033
3034		return event.result;
3035	},
3036
3037	dispatch: function( event ) {
3038
3039		// Make a writable jQuery.Event from the native event object
3040		event = jQuery.event.fix( event );
3041
3042		var i, ret, handleObj, matched, j,
3043			handlerQueue = [],
3044			args = core_slice.call( arguments ),
3045			handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [],
3046			special = jQuery.event.special[ event.type ] || {};
3047
3048		// Use the fix-ed jQuery.Event rather than the (read-only) native event
3049		args[0] = event;
3050		event.delegateTarget = this;
3051
3052		// Call the preDispatch hook for the mapped type, and let it bail if desired
3053		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
3054			return;
3055		}
3056
3057		// Determine handlers
3058		handlerQueue = jQuery.event.handlers.call( this, event, handlers );
3059
3060		// Run delegates first; they may want to stop propagation beneath us
3061		i = 0;
3062		while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) {
3063			event.currentTarget = matched.elem;
3064
3065			j = 0;
3066			while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) {
3067
3068				// Triggered event must either 1) have no namespace, or
3069				// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
3070				if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) {
3071
3072					event.handleObj = handleObj;
3073					event.data = handleObj.data;
3074
3075					ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
3076							.apply( matched.elem, args );
3077
3078					if ( ret !== undefined ) {
3079						if ( (event.result = ret) === false ) {
3080							event.preventDefault();
3081							event.stopPropagation();
3082						}
3083					}
3084				}
3085			}
3086		}
3087
3088		// Call the postDispatch hook for the mapped type
3089		if ( special.postDispatch ) {
3090			special.postDispatch.call( this, event );
3091		}
3092
3093		return event.result;
3094	},
3095
3096	handlers: function( event, handlers ) {
3097		var sel, handleObj, matches, i,
3098			handlerQueue = [],
3099			delegateCount = handlers.delegateCount,
3100			cur = event.target;
3101
3102		// Find delegate handlers
3103		// Black-hole SVG <use> instance trees (#13180)
3104		// Avoid non-left-click bubbling in Firefox (#3861)
3105		if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) {
3106
3107			for ( ; cur != this; cur = cur.parentNode || this ) {
3108
3109				// Don't check non-elements (#13208)
3110				// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
3111				if ( cur.nodeType === 1 && (cur.disabled !== true || event.type !== "click") ) {
3112					matches = [];
3113					for ( i = 0; i < delegateCount; i++ ) {
3114						handleObj = handlers[ i ];
3115
3116						// Don't conflict with Object.prototype properties (#13203)
3117						sel = handleObj.selector + " ";
3118
3119						if ( matches[ sel ] === undefined ) {
3120							matches[ sel ] = handleObj.needsContext ?
3121								jQuery( sel, this ).index( cur ) >= 0 :
3122								jQuery.find( sel, this, null, [ cur ] ).length;
3123						}
3124						if ( matches[ sel ] ) {
3125							matches.push( handleObj );
3126						}
3127					}
3128					if ( matches.length ) {
3129						handlerQueue.push({ elem: cur, handlers: matches });
3130					}
3131				}
3132			}
3133		}
3134
3135		// Add the remaining (directly-bound) handlers
3136		if ( delegateCount < handlers.length ) {
3137			handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) });
3138		}
3139
3140		return handlerQueue;
3141	},
3142
3143	fix: function( event ) {
3144		if ( event[ jQuery.expando ] ) {
3145			return event;
3146		}
3147
3148		// Create a writable copy of the event object and normalize some properties
3149		var i, prop, copy,
3150			type = event.type,
3151			originalEvent = event,
3152			fixHook = this.fixHooks[ type ];
3153
3154		if ( !fixHook ) {
3155			this.fixHooks[ type ] = fixHook =
3156				rmouseEvent.test( type ) ? this.mouseHooks :
3157				rkeyEvent.test( type ) ? this.keyHooks :
3158				{};
3159		}
3160		copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
3161
3162		event = new jQuery.Event( originalEvent );
3163
3164		i = copy.length;
3165		while ( i-- ) {
3166			prop = copy[ i ];
3167			event[ prop ] = originalEvent[ prop ];
3168		}
3169
3170		// Support: IE<9
3171		// Fix target property (#1925)
3172		if ( !event.target ) {
3173			event.target = originalEvent.srcElement || document;
3174		}
3175
3176		// Support: Chrome 23+, Safari?
3177		// Target should not be a text node (#504, #13143)
3178		if ( event.target.nodeType === 3 ) {
3179			event.target = event.target.parentNode;
3180		}
3181
3182		// Support: IE<9
3183		// For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
3184		event.metaKey = !!event.metaKey;
3185
3186		return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
3187	},
3188
3189	// Includes some event props shared by KeyEvent and MouseEvent
3190	props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
3191
3192	fixHooks: {},
3193
3194	keyHooks: {
3195		props: "char charCode key keyCode".split(" "),
3196		filter: function( event, original ) {
3197
3198			// Add which for key events
3199			if ( event.which == null ) {
3200				event.which = original.charCode != null ? original.charCode : original.keyCode;
3201			}
3202
3203			return event;
3204		}
3205	},
3206
3207	mouseHooks: {
3208		props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
3209		filter: function( event, original ) {
3210			var body, eventDoc, doc,
3211				button = original.button,
3212				fromElement = original.fromElement;
3213
3214			// Calculate pageX/Y if missing and clientX/Y available
3215			if ( event.pageX == null && original.clientX != null ) {
3216				eventDoc = event.target.ownerDocument || document;
3217				doc = eventDoc.documentElement;
3218				body = eventDoc.body;
3219
3220				event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
3221				event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
3222			}
3223
3224			// Add relatedTarget, if necessary
3225			if ( !event.relatedTarget && fromElement ) {
3226				event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
3227			}
3228
3229			// Add which for click: 1 === left; 2 === middle; 3 === right
3230			// Note: button is not normalized, so don't use it
3231			if ( !event.which && button !== undefined ) {
3232				event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
3233			}
3234
3235			return event;
3236		}
3237	},
3238
3239	special: {
3240		load: {
3241			// Prevent triggered image.load events from bubbling to window.load
3242			noBubble: true
3243		},
3244		click: {
3245			// For checkbox, fire native event so checked state will be right
3246			trigger: function() {
3247				if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) {
3248					this.click();
3249					return false;
3250				}
3251			}
3252		},
3253		focus: {
3254			// Fire native event if possible so blur/focus sequence is correct
3255			trigger: function() {
3256				if ( this !== document.activeElement && this.focus ) {
3257					try {
3258						this.focus();
3259						return false;
3260					} catch ( e ) {
3261						// Support: IE<9
3262						// If we error on focus to hidden element (#1486, #12518),
3263						// let .trigger() run the handlers
3264					}
3265				}
3266			},
3267			delegateType: "focusin"
3268		},
3269		blur: {
3270			trigger: function() {
3271				if ( this === document.activeElement && this.blur ) {
3272					this.blur();
3273					return false;
3274				}
3275			},
3276			delegateType: "focusout"
3277		},
3278
3279		beforeunload: {
3280			postDispatch: function( event ) {
3281
3282				// Even when returnValue equals to undefined Firefox will still show alert
3283				if ( event.result !== undefined ) {
3284					event.originalEvent.returnValue = event.result;
3285				}
3286			}
3287		}
3288	},
3289
3290	simulate: function( type, elem, event, bubble ) {
3291		// Piggyback on a donor event to simulate a different one.
3292		// Fake originalEvent to avoid donor's stopPropagation, but if the
3293		// simulated event prevents default then we do the same on the donor.
3294		var e = jQuery.extend(
3295			new jQuery.Event(),
3296			event,
3297			{ type: type,
3298				isSimulated: true,
3299				originalEvent: {}
3300			}
3301		);
3302		if ( bubble ) {
3303			jQuery.event.trigger( e, null, elem );
3304		} else {
3305			jQuery.event.dispatch.call( elem, e );
3306		}
3307		if ( e.isDefaultPrevented() ) {
3308			event.preventDefault();
3309		}
3310	}
3311};
3312
3313jQuery.removeEvent = document.removeEventListener ?
3314	function( elem, type, handle ) {
3315		if ( elem.removeEventListener ) {
3316			elem.removeEventListener( type, handle, false );
3317		}
3318	} :
3319	function( elem, type, handle ) {
3320		var name = "on" + type;
3321
3322		if ( elem.detachEvent ) {
3323
3324			// #8545, #7054, preventing memory leaks for custom events in IE6-8
3325			// detachEvent needed property on element, by name of that event, to properly expose it to GC
3326			if ( typeof elem[ name ] === core_strundefined ) {
3327				elem[ name ] = null;
3328			}
3329
3330			elem.detachEvent( name, handle );
3331		}
3332	};
3333
3334jQuery.Event = function( src, props ) {
3335	// Allow instantiation without the 'new' keyword
3336	if ( !(this instanceof jQuery.Event) ) {
3337		return new jQuery.Event( src, props );
3338	}
3339
3340	// Event object
3341	if ( src && src.type ) {
3342		this.originalEvent = src;
3343		this.type = src.type;
3344
3345		// Events bubbling up the document may have been marked as prevented
3346		// by a handler lower down the tree; reflect the correct value.
3347		this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
3348			src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
3349
3350	// Event type
3351	} else {
3352		this.type = src;
3353	}
3354
3355	// Put explicitly provided properties onto the event object
3356	if ( props ) {
3357		jQuery.extend( this, props );
3358	}
3359
3360	// Create a timestamp if incoming event doesn't have one
3361	this.timeStamp = src && src.timeStamp || jQuery.now();
3362
3363	// Mark it as fixed
3364	this[ jQuery.expando ] = true;
3365};
3366
3367// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
3368// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
3369jQuery.Event.prototype = {
3370	isDefaultPrevented: returnFalse,
3371	isPropagationStopped: returnFalse,
3372	isImmediatePropagationStopped: returnFalse,
3373
3374	preventDefault: function() {
3375		var e = this.originalEvent;
3376
3377		this.isDefaultPrevented = returnTrue;
3378		if ( !e ) {
3379			return;
3380		}
3381
3382		// If preventDefault exists, run it on the original event
3383		if ( e.preventDefault ) {
3384			e.preventDefault();
3385
3386		// Support: IE
3387		// Otherwise set the returnValue property of the original event to false
3388		} else {
3389			e.returnValue = false;
3390		}
3391	},
3392	stopPropagation: function() {
3393		var e = this.originalEvent;
3394
3395		this.isPropagationStopped = returnTrue;
3396		if ( !e ) {
3397			return;
3398		}
3399		// If stopPropagation exists, run it on the original event
3400		if ( e.stopPropagation ) {
3401			e.stopPropagation();
3402		}
3403
3404		// Support: IE
3405		// Set the cancelBubble property of the original event to true
3406		e.cancelBubble = true;
3407	},
3408	stopImmediatePropagation: function() {
3409		this.isImmediatePropagationStopped = returnTrue;
3410		this.stopPropagation();
3411	}
3412};
3413
3414// Create mouseenter/leave events using mouseover/out and event-time checks
3415jQuery.each({
3416	mouseenter: "mouseover",
3417	mouseleave: "mouseout"
3418}, function( orig, fix ) {
3419	jQuery.event.special[ orig ] = {
3420		delegateType: fix,
3421		bindType: fix,
3422
3423		handle: function( event ) {
3424			var ret,
3425				target = this,
3426				related = event.relatedTarget,
3427				handleObj = event.handleObj;
3428
3429			// For mousenter/leave call the handler if related is outside the target.
3430			// NB: No relatedTarget if the mouse left/entered the browser window
3431			if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
3432				event.type = handleObj.origType;
3433				ret = handleObj.handler.apply( this, arguments );
3434				event.type = fix;
3435			}
3436			return ret;
3437		}
3438	};
3439});
3440
3441// IE submit delegation
3442if ( !jQuery.support.submitBubbles ) {
3443
3444	jQuery.event.special.submit = {
3445		setup: function() {
3446			// Only need this for delegated form submit events
3447			if ( jQuery.nodeName( this, "form" ) ) {
3448				return false;
3449			}
3450