http://uucps.edu.cn/js/jquery-1.8.2.js

1/*!
2 * jQuery JavaScript Library v1.8.2
3 * http://jquery.com/
4 *
5 * Includes Sizzle.js
6 * http://sizzlejs.com/
7 *
8 * Copyright 2012 jQuery Foundation and other contributors
9 * Released under the MIT license
10 * http://jquery.org/license
11 *
12 * Date: Thu Sep 20 2012 21:13:05 GMT-0400 (Eastern Daylight Time)
13 */
14 
15(function( window, undefined ) {
16var
17	// A central reference to the root jQuery(document)
18	rootjQuery,
19	// The deferred used on DOM ready
20	readyList,
21
22	// Use the correct document accordingly with window argument (sandbox)
23	document = window.document,
24	location = window.location,
25	navigator = window.navigator,
26
27	// Map over jQuery in case of overwrite
28	_jQuery = window.jQuery,
29
30	// Map over the $ in case of overwrite
31	_$ = window.$,
32
33	// Save a reference to some core methods
34	core_push = Array.prototype.push,
35	core_slice = Array.prototype.slice,
36	core_indexOf = Array.prototype.indexOf,
37	core_toString = Object.prototype.toString,
38	core_hasOwn = Object.prototype.hasOwnProperty,
39	core_trim = String.prototype.trim,
40
41	// Define a local copy of jQuery
42	jQuery = function( selector, context ) {
43		// The jQuery object is actually just the init constructor 'enhanced'
44		return new jQuery.fn.init( selector, context, rootjQuery );
45	},
46
47	// Used for matching numbers
48	core_pnum = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source,
49
50	// Used for detecting and trimming whitespace
51	core_rnotwhite = /\S/,
52	core_rspace = /\s+/,
53
54	// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
55	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
56
57	// A simple way to check for HTML strings
58	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
59	rquickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
60
61	// Match a standalone tag
62	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
63
64	// JSON RegExp
65	rvalidchars = /^[\],:{}\s]*$/,
66	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
67	rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
68	rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g,
69
70	// Matches dashed string for camelizing
71	rmsPrefix = /^-ms-/,
72	rdashAlpha = /-([\da-z])/gi,
73
74	// Used by jQuery.camelCase as callback to replace()
75	fcamelCase = function( all, letter ) {
76		return ( letter + "" ).toUpperCase();
77	},
78
79	// The ready event handler and self cleanup method
80	DOMContentLoaded = function() {
81		if ( document.addEventListener ) {
82			document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
83			jQuery.ready();
84		} else if ( document.readyState === "complete" ) {
85			// we're here because readyState === "complete" in oldIE
86			// which is good enough for us to call the dom ready!
87			document.detachEvent( "onreadystatechange", DOMContentLoaded );
88			jQuery.ready();
89		}
90	},
91
92	// [[Class]] -> type pairs
93	class2type = {};
94
95jQuery.fn = jQuery.prototype = {
96	constructor: jQuery,
97	init: function( selector, context, rootjQuery ) {
98		var match, elem, ret, doc;
99
100		// Handle $(""), $(null), $(undefined), $(false)
101		if ( !selector ) {
102			return this;
103		}
104
105		// Handle $(DOMElement)
106		if ( selector.nodeType ) {
107			this.context = this[0] = selector;
108			this.length = 1;
109			return this;
110		}
111
112		// Handle HTML strings
113		if ( typeof selector === "string" ) {
114			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
115				// Assume that strings that start and end with <> are HTML and skip the regex check
116				match = [ null, selector, null ];
117
118			} else {
119				match = rquickExpr.exec( selector );
120			}
121
122			// Match html or make sure no context is specified for #id
123			if ( match && (match[1] || !context) ) {
124
125				// HANDLE: $(html) -> $(array)
126				if ( match[1] ) {
127					context = context instanceof jQuery ? context[0] : context;
128					doc = ( context && context.nodeType ? context.ownerDocument || context : document );
129
130					// scripts is true for back-compat
131					selector = jQuery.parseHTML( match[1], doc, true );
132					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
133						this.attr.call( selector, context, true );
134					}
135
136					return jQuery.merge( this, selector );
137
138				// HANDLE: $(#id)
139				} else {
140					elem = document.getElementById( match[2] );
141
142					// Check parentNode to catch when Blackberry 4.6 returns
143					// nodes that are no longer in the document #6963
144					if ( elem && elem.parentNode ) {
145						// Handle the case where IE and Opera return items
146						// by name instead of ID
147						if ( elem.id !== match[2] ) {
148							return rootjQuery.find( selector );
149						}
150
151						// Otherwise, we inject the element directly into the jQuery object
152						this.length = 1;
153						this[0] = elem;
154					}
155
156					this.context = document;
157					this.selector = selector;
158					return this;
159				}
160
161			// HANDLE: $(expr, $(...))
162			} else if ( !context || context.jquery ) {
163				return ( context || rootjQuery ).find( selector );
164
165			// HANDLE: $(expr, context)
166			// (which is just equivalent to: $(context).find(expr)
167			} else {
168				return this.constructor( context ).find( selector );
169			}
170
171		// HANDLE: $(function)
172		// Shortcut for document ready
173		} else if ( jQuery.isFunction( selector ) ) {
174			return rootjQuery.ready( selector );
175		}
176
177		if ( selector.selector !== undefined ) {
178			this.selector = selector.selector;
179			this.context = selector.context;
180		}
181
182		return jQuery.makeArray( selector, this );
183	},
184
185	// Start with an empty selector
186	selector: "",
187
188	// The current version of jQuery being used
189	jquery: "1.8.2

189",
190
191	// The default length of a jQuery object is 0
192	length: 0,
193
194	// The number of elements contained in the matched element set
195	size: function() {
196		return this.length;
197	},
198
199	toArray: function() {
200		return core_slice.call( this );
201	},
202
203	// Get the Nth element in the matched element set OR
204	// Get the whole matched element set as a clean array
205	get: function( num ) {
206		return num == null ?
207
208			// Return a 'clean' array
209			this.toArray() :
210
211			// Return just the object
212			( num < 0 ? this[ this.length + num ] : this[ num ] );
213	},
214
215	// Take an array of elements and push it onto the stack
216	// (returning the new matched element set)
217	pushStack: function( elems, name, selector ) {
218
219		// Build a new jQuery matched element set
220		var ret = jQuery.merge( this.constructor(), elems );
221
222		// Add the old object onto the stack (as a reference)
223		ret.prevObject = this;
224
225		ret.context = this.context;
226
227		if ( name === "find" ) {
228			ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
229		} else if ( name ) {
230			ret.selector = this.selector + "." + name + "(" + selector + ")";
231		}
232
233		// Return the newly-formed element set
234		return ret;
235	},
236
237	// Execute a callback for every element in the matched set.
238	// (You can seed the arguments with an array of args, but this is
239	// only used internally.)
240	each: function( callback, args ) {
241		return jQuery.each( this, callback, args );
242	},
243
244	ready: function( fn ) {
245		// Add the callback
246		jQuery.ready.promise().done( fn );
247
248		return this;
249	},
250
251	eq: function( i ) {
252		i = +i;
253		return i === -1 ?
254			this.slice( i ) :
255			this.slice( i, i + 1 );
256	},
257
258	first: function() {
259		return this.eq( 0 );
260	},
261
262	last: function() {
263		return this.eq( -1 );
264	},
265
266	slice: function() {
267		return this.pushStack( core_slice.apply( this, arguments ),
268			"slice", core_slice.call(arguments).join(",") );
269	},
270
271	map: function( callback ) {
272		return this.pushStack( jQuery.map(this, function( elem, i ) {
273			return callback.call( elem, i, elem );
274		}));
275	},
276
277	end: function() {
278		return this.prevObject || this.constructor(null);
279	},
280
281	// For internal use only.
282	// Behaves like an Array's method, not like a jQuery method.
283	push: core_push,
284	sort: [].sort,
285	splice: [].splice
286};
287
288// Give the init function the jQuery prototype for later instantiation
289jQuery.fn.init.prototype = jQuery.fn;
290
291jQuery.extend = jQuery.fn.extend = function() {
292	var options, name, src, copy, copyIsArray, clone,
293		target = arguments[0] || {},
294		i = 1,
295		length = arguments.length,
296		deep = false;
297
298	// Handle a deep copy situation
299	if ( typeof target === "boolean" ) {
300		deep = target;
301		target = arguments[1] || {};
302		// skip the boolean and the target
303		i = 2;
304	}
305
306	// Handle case when target is a string or something (possible in deep copy)
307	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
308		target = {};
309	}
310
311	// extend jQuery itself if only one argument is passed
312	if ( length === i ) {
313		target = this;
314		--i;
315	}
316
317	for ( ; i < length; i++ ) {
318		// Only deal with non-null/undefined values
319		if ( (options = arguments[ i ]) != null ) {
320			// Extend the base object
321			for ( name in options ) {
322				src = target[ name ];
323				copy = options[ name ];
324
325				// Prevent never-ending loop
326				if ( target === copy ) {
327					continue;
328				}
329
330				// Recurse if we're merging plain objects or arrays
331				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
332					if ( copyIsArray ) {
333						copyIsArray = false;
334						clone = src && jQuery.isArray(src) ? src : [];
335
336					} else {
337						clone = src && jQuery.isPlainObject(src) ? src : {};
338					}
339
340					// Never move original objects, clone them
341					target[ name ] = jQuery.extend( deep, clone, copy );
342
343				// Don't bring in undefined values
344				} else if ( copy !== undefined ) {
345					target[ name ] = copy;
346				}
347			}
348		}
349	}
350
351	// Return the modified object
352	return target;
353};
354
355jQuery.extend({
356	noConflict: function( deep ) {
357		if ( window.$ === jQuery ) {
358			window.$ = _$;
359		}
360
361		if ( deep && window.jQuery === jQuery ) {
362			window.jQuery = _jQuery;
363		}
364
365		return jQuery;
366	},
367
368	// Is the DOM ready to be used? Set to true once it occurs.
369	isReady: false,
370
371	// A counter to track how many items to wait for before
372	// the ready event fires. See #6781
373	readyWait: 1,
374
375	// Hold (or release) the ready event
376	holdReady: function( hold ) {
377		if ( hold ) {
378			jQuery.readyWait++;
379		} else {
380			jQuery.ready( true );
381		}
382	},
383
384	// Handle when the DOM is ready
385	ready: function( wait ) {
386
387		// Abort if there are pending holds or we're already ready
388		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
389			return;
390		}
391
392		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
393		if ( !document.body ) {
394			return setTimeout( jQuery.ready, 1 );
395		}
396
397		// Remember that the DOM is ready
398		jQuery.isReady = true;
399
400		// If a normal DOM Ready event fired, decrement, and wait if need be
401		if ( wait !== true && --jQuery.readyWait > 0 ) {
402			return;
403		}
404
405		// If there are functions bound, to execute
406		readyList.resolveWith( document, [ jQuery ] );
407
408		// Trigger any bound ready events
409		if ( jQuery.fn.trigger ) {
410			jQuery( document ).trigger("ready").off("ready");
411		}
412	},
413
414	// See test/unit/core.js for details concerning isFunction.
415	// Since version 1.3, DOM methods and functions like alert
416	// aren't supported. They return false on IE (#2968).
417	isFunction: function( obj ) {
418		return jQuery.type(obj) === "function";
419	},
420
421	isArray: Array.isArray || function( obj ) {
422		return jQuery.type(obj) === "array";
423	},
424
425	isWindow: function( obj ) {
426		return obj != null && obj == obj.window;
427	},
428
429	isNumeric: function( obj ) {
430		return !isNaN( parseFloat(obj) ) && isFinite( obj );
431	},
432
433	type: function( obj ) {
434		return obj == null ?
435			String( obj ) :
436			class2type[ core_toString.call(obj) ] || "object";
437	},
438
439	isPlainObject: function( obj ) {
440		// Must be an Object.
441		// Because of IE, we also have to check the presence of the constructor property.
442		// Make sure that DOM nodes and window objects don't pass through, as well
443		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
444			return false;
445		}
446
447		try {
448			// Not own constructor property must be Object
449			if ( obj.constructor &&
450				!core_hasOwn.call(obj, "constructor") &&
451				!core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
452				return false;
453			}
454		} catch ( e ) {
455			// IE8,9 Will throw exceptions on certain host objects #9897
456			return false;
457		}
458
459		// Own properties are enumerated firstly, so to speed up,
460		// if last one is own, then all properties are own.
461
462		var key;
463		for ( key in obj ) {}
464
465		return key === undefined || core_hasOwn.call( obj, key );
466	},
467
468	isEmptyObject: function( obj ) {
469		var name;
470		for ( name in obj ) {
471			return false;
472		}
473		return true;
474	},
475
476	error: function( msg ) {
477		throw new Error( msg );
478	},
479
480	// data: string of html
481	// context (optional): If specified, the fragment will be created in this context, defaults to document
482	// scripts (optional): If true, will include scripts passed in the html string
483	parseHTML: function( data, context, scripts ) {
484		var parsed;
485		if ( !data || typeof data !== "string" ) {
486			return null;
487		}
488		if ( typeof context === "boolean" ) {
489			scripts = context;
490			context = 0;
491		}
492		context = context || document;
493
494		// Single tag
495		if ( (parsed = rsingleTag.exec( data )) ) {
496			return [ context.createElement( parsed[1] ) ];
497		}
498
499		parsed = jQuery.buildFragment( [ data ], context, scripts ? null : [] );
500		return jQuery.merge( [],
501			(parsed.cacheable ? jQuery.clone( parsed.fragment ) : parsed.fragment).childNodes );
502	},
503
504	parseJSON: function( data ) {
505		if ( !data || typeof data !== "string") {
506			return null;
507		}
508
509		// Make sure leading/trailing whitespace is removed (IE can't handle it)
510		data = jQuery.trim( data );
511
512		// Attempt to parse using the native JSON parser first
513		if ( window.JSON && window.JSON.parse ) {
514			return window.JSON.parse( data );
515		}
516
517		// Make sure the incoming data is actual JSON
518		// Logic borrowed from http://json.org/json2.js
519		if ( rvalidchars.test( data.replace( rvalidescape, "@" )
520			.replace( rvalidtokens, "]" )
521			.replace( rvalidbraces, "")) ) {
522
523			return ( new Function( "return " + data ) )();
524
525		}
526		jQuery.error( "Invalid JSON: " + data );
527	},
528
529	// Cross-browser xml parsing
530	parseXML: function( data ) {
531		var xml, tmp;
532		if ( !data || typeof data !== "string" ) {
533			return null;
534		}
535		try {
536			if ( window.DOMParser ) { // Standard
537				tmp = new DOMParser();
538				xml = tmp.parseFromString( data , "text/xml" );
539			} else { // IE
540				xml = new ActiveXObject( "Microsoft.XMLDOM" );
541				xml.async = "false";
542				xml.loadXML( data );
543			}
544		} catch( e ) {
545			xml = undefined;
546		}
547		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
548			jQuery.error( "Invalid XML: " + data );
549		}
550		return xml;
551	},
552
553	noop: function() {},
554
555	// Evaluates a script in a global context
556	// Workarounds based on findings by Jim Driscoll
557	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
558	globalEval: function( data ) {
559		if ( data && core_rnotwhite.test( data ) ) {
560			// We use execScript on Internet Explorer
561			// We use an anonymous function so that context is window
562			// rather than jQuery in Firefox
563			( window.execScript || function( data ) {
564				window[ "eval" ].call( window, data );
565			} )( data );
566		}
567	},
568
569	// Convert dashed to camelCase; used by the css and data modules
570	// Microsoft forgot to hump their vendor prefix (#9572)
571	camelCase: function( string ) {
572		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
573	},
574
575	nodeName: function( elem, name ) {
576		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
577	},
578
579	// args is for internal usage only
580	each: function( obj, callback, args ) {
581		var name,
582			i = 0,
583			length = obj.length,
584			isObj = length === undefined || jQuery.isFunction( obj );
585
586		if ( args ) {
587			if ( isObj ) {
588				for ( name in obj ) {
589					if ( callback.apply( obj[ name ], args ) === false ) {
590						break;
591					}
592				}
593			} else {
594				for ( ; i < length; ) {
595					if ( callback.apply( obj[ i++ ], args ) === false ) {
596						break;
597					}
598				}
599			}
600
601		// A special, fast, case for the most common use of each
602		} else {
603			if ( isObj ) {
604				for ( name in obj ) {
605					if ( callback.call( obj[ name ], name, obj[ name ] ) === false ) {
606						break;
607					}
608				}
609			} else {
610				for ( ; i < length; ) {
611					if ( callback.call( obj[ i ], i, obj[ i++ ] ) === false ) {
612						break;
613					}
614				}
615			}
616		}
617
618		return obj;
619	},
620
621	// Use native String.trim function wherever possible
622	trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
623		function( text ) {
624			return text == null ?
625				"" :
626				core_trim.call( text );
627		} :
628
629		// Otherwise use our own trimming functionality
630		function( text ) {
631			return text == null ?
632				"" :
633				( text + "" ).replace( rtrim, "" );
634		},
635
636	// results is for internal usage only
637	makeArray: function( arr, results ) {
638		var type,
639			ret = results || [];
640
641		if ( arr != null ) {
642			// The window, strings (and functions) also have 'length'
643			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
644			type = jQuery.type( arr );
645
646			if ( arr.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( arr ) ) {
647				core_push.call( ret, arr );
648			} else {
649				jQuery.merge( ret, arr );
650			}
651		}
652
653		return ret;
654	},
655
656	inArray: function( elem, arr, i ) {
657		var len;
658
659		if ( arr ) {
660			if ( core_indexOf ) {
661				return core_indexOf.call( arr, elem, i );
662			}
663
664			len = arr.length;
665			i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
666
667			for ( ; i < len; i++ ) {
668				// Skip accessing in sparse arrays
669				if ( i in arr && arr[ i ] === elem ) {
670					return i;
671				}
672			}
673		}
674
675		return -1;
676	},
677
678	merge: function( first, second ) {
679		var l = second.length,
680			i = first.length,
681			j = 0;
682
683		if ( typeof l === "number" ) {
684			for ( ; j < l; j++ ) {
685				first[ i++ ] = second[ j ];
686			}
687
688		} else {
689			while ( second[j] !== undefined ) {
690				first[ i++ ] = second[ j++ ];
691			}
692		}
693
694		first.length = i;
695
696		return first;
697	},
698
699	grep: function( elems, callback, inv ) {
700		var retVal,
701			ret = [],
702			i = 0,
703			length = elems.length;
704		inv = !!inv;
705
706		// Go through the array, only saving the items
707		// that pass the validator function
708		for ( ; i < length; i++ ) {
709			retVal = !!callback( elems[ i ], i );
710			if ( inv !== retVal ) {
711				ret.push( elems[ i ] );
712			}
713		}
714
715		return ret;
716	},
717
718	// arg is for internal usage only
719	map: function( elems, callback, arg ) {
720		var value, key,
721			ret = [],
722			i = 0,
723			length = elems.length,
724			// jquery objects are treated as arrays
725			isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
726
727		// Go through the array, translating each of the items to their
728		if ( isArray ) {
729			for ( ; i < length; i++ ) {
730				value = callback( elems[ i ], i, arg );
731
732				if ( value != null ) {
733					ret[ ret.length ] = value;
734				}
735			}
736
737		// Go through every key on the object,
738		} else {
739			for ( key in elems ) {
740				value = callback( elems[ key ], key, arg );
741
742				if ( value != null ) {
743					ret[ ret.length ] = value;
744				}
745			}
746		}
747
748		// Flatten any nested arrays
749		return ret.concat.apply( [], ret );
750	},
751
752	// A global GUID counter for objects
753	guid: 1,
754
755	// Bind a function to a context, optionally partially applying any
756	// arguments.
757	proxy: function( fn, context ) {
758		var tmp, args, proxy;
759
760		if ( typeof context === "string" ) {
761			tmp = fn[ context ];
762			context = fn;
763			fn = tmp;
764		}
765
766		// Quick check to determine if target is callable, in the spec
767		// this throws a TypeError, but we will just return undefined.
768		if ( !jQuery.isFunction( fn ) ) {
769			return undefined;
770		}
771
772		// Simulated bind
773		args = core_slice.call( arguments, 2 );
774		proxy = function() {
775			return fn.apply( context, args.concat( core_slice.call( arguments ) ) );
776		};
777
778		// Set the guid of unique handler to the same of original handler, so it can be removed
779		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
780
781		return proxy;
782	},
783
784	// Multifunctional method to get and set values of a collection
785	// The value/s can optionally be executed if it's a function
786	access: function( elems, fn, key, value, chainable, emptyGet, pass ) {
787		var exec,
788			bulk = key == null,
789			i = 0,
790			length = elems.length;
791
792		// Sets many values
793		if ( key && typeof key === "object" ) {
794			for ( i in key ) {
795				jQuery.access( elems, fn, i, key[i], 1, emptyGet, value );
796			}
797			chainable = 1;
798
799		// Sets one value
800		} else if ( value !== undefined ) {
801			// Optionally, function values get executed if exec is true
802			exec = pass === undefined && jQuery.isFunction( value );
803
804			if ( bulk ) {
805				// Bulk operations only iterate when executing function values
806				if ( exec ) {
807					exec = fn;
808					fn = function( elem, key, value ) {
809						return exec.call( jQuery( elem ), value );
810					};
811
812				// Otherwise they run against the entire set
813				} else {
814					fn.call( elems, value );
815					fn = null;
816				}
817			}
818
819			if ( fn ) {
820				for (; i < length; i++ ) {
821					fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
822				}
823			}
824
825			chainable = 1;
826		}
827
828		return chainable ?
829			elems :
830
831			// Gets
832			bulk ?
833				fn.call( elems ) :
834				length ? fn( elems[0], key ) : emptyGet;
835	},
836
837	now: function() {
838		return ( new Date() ).getTime();
839	}
840});
841
842jQuery.ready.promise = function( obj ) {
843	if ( !readyList ) {
844
845		readyList = jQuery.Deferred();
846
847		// Catch cases where $(document).ready() is called after the browser event has already occurred.
848		// we once tried to use readyState "interactive" here, but it caused issues like the one
849		// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
850		if ( document.readyState === "complete" ) {
851			// Handle it asynchronously to allow scripts the opportunity to delay ready
852			setTimeout( jQuery.ready, 1 );
853
854		// Standards-based browsers support DOMContentLoaded
855		} else if ( document.addEventListener ) {
856			// Use the handy event callback
857			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
858
859			// A fallback to window.onload, that will always work
860			window.addEventListener( "load", jQuery.ready, false );
861
862		// If IE event model is used
863		} else {
864			// Ensure firing before onload, maybe late but safe also for iframes
865			document.attachEvent( "onreadystatechange", DOMContentLoaded );
866
867			// A fallback to window.onload, that will always work
868			window.attachEvent( "onload", jQuery.ready );
869
870			// If IE and not a frame
871			// continually check to see if the document is ready
872			var top = false;
873
874			try {
875				top = window.frameElement == null && document.documentElement;
876			} catch(e) {}
877
878			if ( top && top.doScroll ) {
879				(function doScrollCheck() {
880					if ( !jQuery.isReady ) {
881
882						try {
883							// Use the trick by Diego Perini
884							// http://javascript.nwbox.com/IEContentLoaded/
885							top.doScroll("left");
886						} catch(e) {
887							return setTimeout( doScrollCheck, 50 );
888						}
889
890						// and execute any waiting functions
891						jQuery.ready();
892					}
893				})();
894			}
895		}
896	}
897	return readyList.promise( obj );
898};
899
900// Populate the class2type map
901jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
902	class2type[ "[object " + name + "]" ] = name.toLowerCase();
903});
904
905// All jQuery objects should point back to these
906rootjQuery = jQuery(document);
907// String to Object options format cache
908var optionsCache = {};
909
910// Convert String-formatted options into Object-formatted ones and store in cache
911function createOptions( options ) {
912	var object = optionsCache[ options ] = {};
913	jQuery.each( options.split( core_rspace ), function( _, flag ) {
914		object[ flag ] = true;
915	});
916	return object;
917}
918
919/*
920 * Create a callback list using the following parameters:
921 *
922 *	options: an optional list of space-separated options that will change how
923 *			the callback list behaves or a more traditional option object
924 *
925 * By default a callback list will act like an event callback list and can be
926 * "fired" multiple times.
927 *
928 * Possible options:
929 *
930 *	once:			will ensure the callback list can only be fired once (like a Deferred)
931 *
932 *	memory:			will keep track of previous values and will call any callback added
933 *					after the list has been fired right away with the latest "memorized"
934 *					values (like a Deferred)
935 *
936 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
937 *
938 *	stopOnFalse:	interrupt callings when a callback returns false
939 *
940 */
941jQuery.Callbacks = function( options ) {
942
943	// Convert options from String-formatted to Object-formatted if needed
944	// (we check in cache first)
945	options = typeof options === "string" ?
946		( optionsCache[ options ] || createOptions( options ) ) :
947		jQuery.extend( {}, options );
948
949	var // Last fire value (for non-forgettable lists)
950		memory,
951		// Flag to know if list was already fired
952		fired,
953		// Flag to know if list is currently firing
954		firing,
955		// First callback to fire (used internally by add and fireWith)
956		firingStart,
957		// End of the loop when firing
958		firingLength,
959		// Index of currently firing callback (modified by remove if needed)
960		firingIndex,
961		// Actual callback list
962		list = [],
963		// Stack of fire calls for repeatable lists
964		stack = !options.once && [],
965		// Fire callbacks
966		fire = function( data ) {
967			memory = options.memory && data;
968			fired = true;
969			firingIndex = firingStart || 0;
970			firingStart = 0;
971			firingLength = list.length;
972			firing = true;
973			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
974				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
975					memory = false; // To prevent further calls using add
976					break;
977				}
978			}
979			firing = false;
980			if ( list ) {
981				if ( stack ) {
982					if ( stack.length ) {
983						fire( stack.shift() );
984					}
985				} else if ( memory ) {
986					list = [];
987				} else {
988					self.disable();
989				}
990			}
991		},
992		// Actual Callbacks object
993		self = {
994			// Add a callback or a collection of callbacks to the list
995			add: function() {
996				if ( list ) {
997					// First, we save the current length
998					var start = list.length;
999					(function add( args ) {
1000						jQuery.each( args, function( _, arg ) {
1001							var type = jQuery.type( arg );
1002							if ( type === "function" 

1002&& ( !options.unique || !self.has( arg ) ) ) {
1003								list.push( arg );
1004							} else if ( arg && arg.length && type !== "string" ) {
1005								// Inspect recursively
1006								add( arg );
1007							}
1008						});
1009					})( arguments );
1010					// Do we need to add the callbacks to the
1011					// current firing batch?
1012					if ( firing ) {
1013						firingLength = list.length;
1014					// With memory, if we're not firing then
1015					// we should call right away
1016					} else if ( memory ) {
1017						firingStart = start;
1018						fire( memory );
1019					}
1020				}
1021				return this;
1022			},
1023			// Remove a callback from the list
1024			remove: function() {
1025				if ( list ) {
1026					jQuery.each( arguments, function( _, arg ) {
1027						var index;
1028						while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
1029							list.splice( index, 1 );
1030							// Handle firing indexes
1031							if ( firing ) {
1032								if ( index <= firingLength ) {
1033									firingLength--;
1034								}
1035								if ( index <= firingIndex ) {
1036									firingIndex--;
1037								}
1038							}
1039						}
1040					});
1041				}
1042				return this;
1043			},
1044			// Control if a given callback is in the list
1045			has: function( fn ) {
1046				return jQuery.inArray( fn, list ) > -1;
1047			},
1048			// Remove all callbacks from the list
1049			empty: function() {
1050				list = [];
1051				return this;
1052			},
1053			// Have the list do nothing anymore
1054			disable: function() {
1055				list = stack = memory = undefined;
1056				return this;
1057			},
1058			// Is it disabled?
1059			disabled: function() {
1060				return !list;
1061			},
1062			// Lock the list in its current state
1063			lock: function() {
1064				stack = undefined;
1065				if ( !memory ) {
1066					self.disable();
1067				}
1068				return this;
1069			},
1070			// Is it locked?
1071			locked: function() {
1072				return !stack;
1073			},
1074			// Call all callbacks with the given context and arguments
1075			fireWith: function( context, args ) {
1076				args = args || [];
1077				args = [ context, args.slice ? args.slice() : args ];
1078				if ( list && ( !fired || stack ) ) {
1079					if ( firing ) {
1080						stack.push( args );
1081					} else {
1082						fire( args );
1083					}
1084				}
1085				return this;
1086			},
1087			// Call all the callbacks with the given arguments
1088			fire: function() {
1089				self.fireWith( this, arguments );
1090				return this;
1091			},
1092			// To know if the callbacks have already been called at least once
1093			fired: function() {
1094				return !!fired;
1095			}
1096		};
1097
1098	return self;
1099};
1100jQuery.extend({
1101
1102	Deferred: function( func ) {
1103		var tuples = [
1104				// action, add listener, listener list, final state
1105				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
1106				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
1107				[ "notify", "progress", jQuery.Callbacks("memory") ]
1108			],
1109			state = "pending",
1110			promise = {
1111				state: function() {
1112					return state;
1113				},
1114				always: function() {
1115					deferred.done( arguments ).fail( arguments );
1116					return this;
1117				},
1118				then: function( /* fnDone, fnFail, fnProgress */ ) {
1119					var fns = arguments;
1120					return jQuery.Deferred(function( newDefer ) {
1121						jQuery.each( tuples, function( i, tuple ) {
1122							var action = tuple[ 0 ],
1123								fn = fns[ i ];
1124							// deferred[ done | fail | progress ] for forwarding actions to newDefer
1125							deferred[ tuple[1] ]( jQuery.isFunction( fn ) ?
1126								function() {
1127									var returned = fn.apply( this, arguments );
1128									if ( returned && jQuery.isFunction( returned.promise ) ) {
1129										returned.promise()
1130											.done( newDefer.resolve )
1131											.fail( newDefer.reject )
1132											.progress( newDefer.notify );
1133									} else {
1134										newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
1135									}
1136								} :
1137								newDefer[ action ]
1138							);
1139						});
1140						fns = null;
1141					}).promise();
1142				},
1143				// Get a promise for this deferred
1144				// If obj is provided, the promise aspect is added to the object
1145				promise: function( obj ) {
1146					return obj != null ? jQuery.extend( obj, promise ) : promise;
1147				}
1148			},
1149			deferred = {};
1150
1151		// Keep pipe for back-compat
1152		promise.pipe = promise.then;
1153
1154		// Add list-specific methods
1155		jQuery.each( tuples, function( i, tuple ) {
1156			var list = tuple[ 2 ],
1157				stateString = tuple[ 3 ];
1158
1159			// promise[ done | fail | progress ] = list.add
1160			promise[ tuple[1] ] = list.add;
1161
1162			// Handle state
1163			if ( stateString ) {
1164				list.add(function() {
1165					// state = [ resolved | rejected ]
1166					state = stateString;
1167
1168				// [ reject_list | resolve_list ].disable; progress_list.lock
1169				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
1170			}
1171
1172			// deferred[ resolve | reject | notify ] = list.fire
1173			deferred[ tuple[0] ] = list.fire;
1174			deferred[ tuple[0] + "With" ] = list.fireWith;
1175		});
1176
1177		// Make the deferred a promise
1178		promise.promise( deferred );
1179
1180		// Call given func if any
1181		if ( func ) {
1182			func.call( deferred, deferred );
1183		}
1184
1185		// All done!
1186		return deferred;
1187	},
1188
1189	// Deferred helper
1190	when: function( subordinate /* , ..., subordinateN */ ) {
1191		var i = 0,
1192			resolveValues = core_slice.call( arguments ),
1193			length = resolveValues.length,
1194
1195			// the count of uncompleted subordinates
1196			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
1197
1198			// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
1199			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
1200
1201			// Update function for both resolve and progress values
1202			updateFunc = function( i, contexts, values ) {
1203				return function( value ) {
1204					contexts[ i ] = this;
1205					values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
1206					if( values === progressValues ) {
1207						deferred.notifyWith( contexts, values );
1208					} else if ( !( --remaining ) ) {
1209						deferred.resolveWith( contexts, values );
1210					}
1211				};
1212			},
1213
1214			progressValues, progressContexts, resolveContexts;
1215
1216		// add listeners to Deferred subordinates; treat others as resolved
1217		if ( length > 1 ) {
1218			progressValues = new Array( length );
1219			progressContexts = new Array( length );
1220			resolveContexts = new Array( length );
1221			for ( ; i < length; i++ ) {
1222				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
1223					resolveValues[ i ].promise()
1224						.done( updateFunc( i, resolveContexts, resolveValues ) )
1225						.fail( deferred.reject )
1226						.progress( updateFunc( i, progressContexts, progressValues ) );
1227				} else {
1228					--remaining;
1229				}
1230			}
1231		}
1232
1233		// if we're not waiting on anything, resolve the master
1234		if ( !remaining ) {
1235			deferred.resolveWith( resolveContexts, resolveValues );
1236		}
1237
1238		return deferred.promise();
1239	}
1240});
1241jQuery.support = (function() {
1242
1243	var support,
1244		all,
1245		a,
1246		select,
1247		opt,
1248		input,
1249		fragment,
1250		eventName,
1251		i,
1252		isSupported,
1253		clickFn,
1254		div = document.createElement("div");
1255
1256	// Preliminary tests
1257	div.setAttribute( "className", "t" );
1258	div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
1259
1260	all = div.getElementsByTagName("*");
1261	a = div.getElementsByTagName("a")[ 0 ];
1262	a.style.cssText = "top:1px;float:left;opacity:.5";
1263
1264	// Can't get basic test support
1265	if ( !all || !all.length ) {
1266		return {};
1267	}
1268
1269	// First batch of supports tests
1270	select = document.createElement("select");
1271	opt = select.appendChild( document.createElement("option") );
1272	input = div.getElementsByTagName("input")[ 0 ];
1273
1274	support = {
1275		// IE strips leading whitespace when .innerHTML is used
1276		leadingWhitespace: ( div.firstChild.nodeType === 3 ),
1277
1278		// Make sure that tbody elements aren't automatically inserted
1279		// IE will insert them into empty tables
1280		tbody: !div.getElementsByTagName("tbody").length,
1281
1282		// Make sure that link elements get serialized correctly by innerHTML
1283		// This requires a wrapper element in IE
1284		htmlSerialize: !!div.getElementsByTagName("link").length,
1285
1286		// Get the style information from getAttribute
1287		// (IE uses .cssText instead)
1288		style: /top/.test( a.getAttribute("style") ),
1289
1290		// Make sure that URLs aren't manipulated
1291		// (IE normalizes it by default)
1292		hrefNormalized: ( a.getAttribute("href") === "/a" ),

1315(#6743)
1316		enctype: !!document.createElement("form").enctype,
1317
1318		// Makes sure cloning an html5 element does not cause problems
1319		// Where outerHTML is undefined, this still works
1320		html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
1321
1322		// jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
1323		boxModel: ( document.compatMode === "CSS1Compat" ),
1324
1325		// Will be defined later
1326		submitBubbles: true,
1327		changeBubbles: true,
1328		focusinBubbles: false,
1329		deleteExpando: true,
1330		noCloneEvent: true,
1331		inlineBlockNeedsLayout: false,
1332		shrinkWrapBlocks: false,
1333		reliableMarginRight: true,
1334		boxSizingReliable: true,
1335		pixelPosition: false
1336	};
1337
1338	// Make sure checked status is properly cloned
1339	input.checked = true;
1340	support.noCloneChecked = input.cloneNode( true ).checked;
1341
1342	// Make sure that the options inside disabled selects aren't marked as disabled
1343	// (WebKit marks them as disabled)
1344	select.disabled = true;
1345	support.optDisabled = !opt.disabled;
1346
1347	// Test to see if it's possible to delete an expando from an element
1348	// Fails in Internet Explorer
1349	try {
1350		delete div.test;
1351	} catch( e ) {
1352		support.deleteExpando = false;
1353	}
1354
1355	if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1356		div.attachEvent( "onclick", clickFn = function() {
1357			// Cloning a node shouldn't copy over any
1358			// bound event handlers (IE does this)
1359			support.noCloneEvent = false;
1360		});
1361		div.cloneNode( true ).fireEvent("onclick");
1362		div.detachEvent( "onclick", clickFn );
1363	}
1364
1365	// Check if a radio maintains its value
1366	// after being appended to the DOM
1367	input = document.createElement("input");
1368	input.value = "t";
1369	input.setAttribute( "type", "radio" );
1370	support.radioValue = input.value === "t";
1371
1372	input.setAttribute( "checked", "checked" );
1373
1374	// #11217 - WebKit loses check when the name is after the checked attribute
1375	input.setAttribute( "name", "t" );
1376
1377	div.appendChild( input );
1378	fragment = document.createDocumentFragment();
1379	fragment.appendChild( div.lastChild );
1380
1381	// WebKit doesn't clone checked state correctly in fragments
1382	support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
1383
1384	// Check if a disconnected checkbox will retain its checked
1385	// value of true after appended to the DOM (IE6/7)
1386	support.appendChecked = input.checked;
1387
1388	fragment.removeChild( input );
1389	fragment.appendChild( div );
1390
1391	// Technique from Juriy Zaytsev
1392	// http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
1393	// We only care about the case where non-standard event systems
1394	// are used, namely in IE. Short-circuiting here helps us to
1395	// avoid an eval call (in setAttribute) which can cause CSP
1396	// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1397	if ( div.attachEvent ) {
1398		for ( i in {
1399			submit: true,
1400			change: true,
1401			focusin: true
1402		}) {
1403			eventName = "on" + i;
1404			isSupported = ( eventName in div );
1405			if ( !isSupported ) {
1406				div.setAttribute( eventName, "return;" );
1407				isSupported = ( typeof div[ eventName ] === "function" );
1408			}
1409			support[ i + "Bubbles" ] = isSupported;
1410		}
1411	}
1412
1413	// Run tests that need a body at doc ready
1414	jQuery(function() {
1415		var container, div, tds, marginDiv,
1416			divReset = "padding:0;margin:0;border:0;display:block;overflow:hidden;",
1417			body = document.getElementsByTagName("body")[0];
1418
1419		if ( !body ) {
1420			// Return for frameset docs that don't have a body
1421			return;
1422		}
1423
1424		container = document.createElement("div");
1425		container.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px";
1426		body.insertBefore( container, body.firstChild );
1427
1428		// Construct the test element
1429		div = document.createElement("div");
1430		container.appendChild( div );
1431
1432		// Check if table cells still have offsetWidth/Height when they are set
1433		// to display:none and there are still other visible table cells in a
1434		// table row; if so, offsetWidth/Height are not reliable for use when
1435		// determining if an element has been hidden directly using
1436		// display:none (it is still safe to use offsets if a parent element is
1437		// hidden; don safety goggles and see bug #4512 for more information).
1438		// (only IE 8 fails this test)
1439		div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
1440		tds = div.getElementsByTagName("td");
1441		tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
1442		isSupported = ( tds[ 0 ].offsetHeight === 0 );
1443
1444		tds[ 0 ].style.display = "";
1445		tds[ 1 ].style.display = "none";
1446
1447		// Check if empty table cells still have offsetWidth/Height
1448		// (IE <= 8 fail this test)
1449		support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1450
1451		// Check box-sizing and margin behavior
1452		div.innerHTML = "";
1453		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%;";
1454		support.boxSizing = ( div.offsetWidth === 4 );
1455		support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
1456
1457		// NOTE: To any future maintainer, we've window.getComputedStyle
1458		// because jsdom on node.js will break without it.
1459		if ( window.getComputedStyle ) {
1460			support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
1461			support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
1462
1463			// Check if div with explicit width and no margin-right incorrectly
1464			// gets computed margin-right based on width of container. For more
1465			// info see bug #3333
1466			// Fails in WebKit before Feb 2011 nightlies
1467			// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1468			marginDiv = document.createElement("div");
1469			marginDiv.style.cssText = div.style.cssText = divReset;
1470			marginDiv.style.marginRight = marginDiv.style.width = "0";
1471			div.style.width = "1px";
1472			div.appendChild( marginDiv );
1473			support.reliableMarginRight =
1474				!parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
1475		}
1476
1477		if ( typeof div.style.zoom !== "undefined" ) {
1478			// Check if natively block-level elements act like inline-block
1479			// elements when setting their display to 'inline' and giving
1480			// them layout
1481			// (IE < 8 does this)
1482			div.innerHTML = "";
1483			div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
1484			support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
1485
1486			// Check if elements with layout shrink-wrap their children
1487			// (IE 6 does this)
1488			div.style.display = "block";
1489			div.style.overflow = "visible";
1490			div.innerHTML = "<div></div>";
1491			div.firstChild.style.width = "5px";
1492			support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
1493
1494			container.style.zoom = 1;
1495		}
1496
1497		// Null elements to avoid leaks in IE
1498		body.removeChild( container );
1499		container = div = tds = marginDiv = null;
1500	});
1501
1502	// Null elements to avoid leaks in IE
1503	fragment.removeChild( div );
1504	all = a = select = opt = input = fragment = div = null;
1505
1506	return support;
1507})();
1508var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
1509	rmultiDash = /([A-Z])/g;
1510
1511jQuery.extend({
1512	cache: {},
1513
1514	deletedIds: [],
1515
1516	// Remove at next major release (1.9/2.0)
1517	uuid: 0,
1518
1519	// Unique for each copy of jQuery on the page
1520	// Non-digits removed to match rinlinejQuery
1521	expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1522
1523	// The following elements throw uncatchable exceptions if you
1524	// attempt to add expando properties to them.
1525	noData: {
1526		"embed": true,
1527		// Ban all objects except for Flash (which handle expandos)
1528		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1529		"applet": true
1530	},
1531
1532	hasData: function( elem ) {
1533		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1534		return !!elem && !isEmptyDataObject( elem );
1535	},
1536
1537	data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1538		if ( !jQuery.acceptData( elem ) ) {
1539			return;
1540		}
1541
1542		var thisCache, ret,
1543			internalKey = jQuery.expando,
1544			getByName = typeof name === "string",
1545
1546			// We have to handle DOM nodes and JS objects differently because IE6-7
1547			// can't GC object references properly across the DOM-JS boundary
1548			isNode = elem.nodeType,
1549
1550			// Only DOM nodes need the global jQuery cache; JS object data is
1551			// attached directly to the object so GC can occur automatically
1552			cache = isNode ? jQuery.cache : elem,
1553
1554			// Only defining an ID for JS objects if its cache already exists allows
1555			// the code to shortcut on the same path as a DOM node with no cache
1556			id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
1557
1558		// Avoid doing any more work than we need to when trying to get data on an
1559		// object that has no data at all
1560		if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) {
1561			return;
1562		}
1563
1564		if ( !id ) {
1565			// Only DOM nodes need a new unique ID for each element since their data
1566			// ends up in the global cache
1567			if ( isNode ) {
1568				elem[ internalKey ] = id = jQuery.deletedIds.pop() || jQuery.guid++;
1569			} else {
1570				id = internalKey;
1571			}
1572		}
1573
1574		if ( !cache[ id ] ) {
1575			cache[ id ] = {};
1576
1577			// Avoids exposing jQuery metadata on plain JS objects when the object
1578			// is serialized using JSON.stringify
1579			if ( !isNode ) {
1580				cache[ id ].toJSON = jQuery.noop;
1581			}
1582		}
1583
1584		// An object can be passed to jQuery.data instead of a key/value pair; this gets
1585		// shallow copied over onto the existing cache
1586		if ( typeof name === "object" || typeof name === "function" ) {
1587			if ( pvt ) {
1588				cache[ id ] = jQuery.extend( cache[ id ], name );
1589			} else {
1590				cache[ id ].data = jQuery.extend( cache[ id ].data, name );
1591			}
1592		}
1593
1594		thisCache = cache[ id ];
1595
1596		// jQuery data() is stored in a separate object inside the object's internal data
1597		// cache in order to avoid key collisions between internal data and user-defined
1598		// data.
1599		if ( !pvt ) {
1600			if ( !thisCache.data ) {
1601				thisCache.data = {};
1602			}
1603
1604			thisCache = thisCache.data;
1605		}
1606
1607		if ( data !== undefined ) {
1608			thisCache[ jQuery.camelCase( name ) ] = data;
1609		}
1610
1611		// Check for both converted-to-camel and non-converted data property names
1612		// If a data property was specified
1613		if ( getByName ) {
1614
1615			// First Try to find as-is property data
1616			ret = thisCache[ name ];
1617
1618			// Test for null|undefined property data
1619			if ( ret == null ) {
1620
1621				// Try to find the camelCased property
1622				ret = thisCache[ jQuery.camelCase( name ) ];
1623			}
1624		} else {
1625			ret = thisCache;
1626		}
1627
1628		return ret;
1629	},
1630
1631	removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1632		if ( !jQuery.acceptData( elem ) ) {
1633			return;
1634		}
1635
1636		var thisCache, i, l,
1637
1638			isNode = elem.nodeType,
1639
1640			// See jQuery.data for more information
1641			cache = isNode ? jQuery.cache : elem,
1642			id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
1643
1644		// If there is already no cache entry for this object, there is no
1645		// purpose in continuing
1646		if ( !cache[ id ] ) {
1647			return;
1648		}
1649
1650		if ( name ) {
1651
1652			thisCache = pvt ? cache[ id ] : cache[ id ].data;
1653
1654			if ( thisCache ) {
1655
1656				// Support array or space separated string names for data keys
1657				if ( !jQuery.isArray( name ) ) {
1658
1659					// try the string as a key before any manipulation
1660					if ( name in thisCache ) {
1661						name = [ name ];
1662					} else {
1663
1664						// split the camel cased version by spaces unless a key with the spaces exists
1665						name = jQuery.camelCase( name );
1666						if ( name in thisCache ) {
1667							name = [ name ];
1668						} else {
1669							name = name.split(" ");
1670						}
1671					}
1672				}
1673
1674				for ( i = 0, l = name.length; i < l; i++ ) {
1675					delete thisCache[ name[i] ];
1676				}
1677
1678				// If there is no data left in the cache, we want to continue
1679				// and let the cache object itself get destroyed
1680				if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
1681					return;
1682				}
1683			}
1684		}
1685
1686		// See jQuery.data for more information
1687		if ( !pvt ) {
1688			delete cache[ id ].data;
1689
1690			// Don't destroy the parent cache unless the internal data object
1691			// had been the only thing left in it
1692			if ( !isEmptyDataObject( cache[ id ] ) ) {
1693				return;
1694			}
1695		}
1696
1697		// Destroy the cache
1698		if ( isNode ) {
1699			jQuery.cleanData( [ elem ], true );
1700
1701		// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
1702		} else if ( jQuery.support.deleteExpando || cache != cache.window ) {
1703			delete cache[ id ];
1704
1705		// When all else fails, null
1706		} else {
1707			cache[ id ] = null;
1708		}
1709	},
1710
1711	// For internal use only.
1712	_data: function( elem, name, data ) {
1713		return jQuery.data( elem, name, data, true );
1714	},
1715
1716	// A method for determining if a DOM node can handle the data expando
1717	acceptData: function( elem ) {
1718		var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];
1719
1720		// nodes accept data unless otherwise specified; rejection can be conditional
1721		return !noData || noData !== true && elem.getAttribute("classid") === noData;
1722	}
1723});
1724
1725jQuery.fn.extend({
1726	data: function( key, value ) {
1727		var parts, part, attr, name, l,
1728			elem = this[0],
1729			i = 0,
1730			data = null;
1731
1732		// Gets all values
1733		if ( key === undefined ) {
1734			if ( this.length ) {
1735				data = jQuery.data( elem );
1736
1737				if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
1738					attr = elem.attributes;
1739					for ( l = attr.length; i < l; i++ ) {
1740						name = attr[i].name;
1741
1742						if ( !name.indexOf( "data-" ) ) {
1743							name = jQuery.camelCase( name.substring(5) );
1744
1745							dataAttr( elem, name, data[ name ] );
1746						}
1747					}
1748					jQuery._data( elem, "parsedAttrs", true );
1749				}
1750			}
1751
1752			return data;
1753		}
1754
1755		// Sets multiple values
1756		if ( typeof key === "object" ) {
1757			return this.each(function() {
1758				jQuery.data( this, key );
1759			});
1760		}
1761
1762		parts = key.split( ".", 2 );
1763		parts[1] = parts[1] ? "." + parts[1] : "";
1764		part = parts[1] + "!";
1765
1766		return jQuery.access( this, function( value ) {
1767
1768			if ( value === undefined ) {
1769				data = this.triggerHandler( "getData" + part, [ parts[0] ] );
1770
1771				// Try to fetch any internally stored data first
1772				if ( data === undefined && elem ) {
1773					data = jQuery.data( elem, key );
1774					data = dataAttr( elem, key, data );
1775				}
1776
1777				return data === undefined && parts[1] ?
1778					this.data( parts[0] ) :
1779					data;
1780			}
1781
1782			parts[1] = value;
1783			this.each(function() {
1784				var self = jQuery( this );
1785
1786				self.triggerHandler( "setData" + part, parts );
1787				jQuery.data( this, key, value );
1788				self.triggerHandler( "changeData" + part, parts );
1789			});
1790		}, null, value, arguments.length > 1, null, false );
1791	},
1792
1793	removeData: function( key ) {
1794		return this.each(function() {
1795			jQuery.removeData( this, key );
1796		});
1797	}
1798});
1799
1800function dataAttr( elem, key, data ) {
1801	// If nothing was found internally, try to fetch any
1802	// data from the HTML5 data-* attribute
1803	if ( data === undefined && elem.nodeType === 1 ) {
1804
1805		var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
1806
1807		data = elem.getAttribute( name );
1808
1809		if ( typeof data === "string" ) {
1810			try {
1811				data = data === "true" ? true :
1812				data === "false" ? false :
1813				data === "null" ? null :
1814				// Only convert to a number if it doesn't change the string
1815				+data + "" === data ? +data :
1816				rbrace.test( data ) ? jQuery.parseJSON( data ) :
1817					data;
1818			} catch( e ) {}
1819
1820			// Make sure we set the data so it isn't changed later
1821			jQuery.data( elem, key, data );
1822
1823		} else {
1824			data = undefined;
1825		}
1826	}
1827
1828	return data;
1829}
1830
1831// checks a cache object for emptiness
1832function isEmptyDataObject( obj ) {
1833	var name;
1834	for ( name in obj ) {
1835
1836		// if the public data object is empty, the private is still empty
1837		if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
1838			continue;
1839		}
1840		if ( name !== "toJSON" ) {
1841			return false;
1842		}
1843	}
1844
1845	return true;
1846}
1847jQuery.extend({
1848	queue: function( elem, type, data ) {
1849		var queue;
1850
1851		if ( elem ) {
1852			type = ( type || "fx" ) + "queue";
1853			queue = jQuery._data( elem, type );
1854
1855			// Speed up dequeue by getting out quickly if this is just a lookup
1856			if ( data ) {
1857				if ( !queue || jQuery.isArray(data) ) {
1858					queue = jQuery._data( elem, type, jQuery.makeArray(data) );
1859				} else {
1860					queue.push( data );
1861				}
1862			}
1863			return queue || [];
1864		}
1865	},
1866
1867	dequeue: function( elem, type ) {
1868		type = type || "fx";
1869
1870		var queue = jQuery.queue( elem, type ),
1871			startLength = queue.length,
1872			fn = queue.shift(),
1873			hooks = jQuery._queueHooks( elem, type ),
1874			next = function() {
1875				jQuery.dequeue( elem, type );
1876			};
1877
1878		// If the fx queue is dequeued, always remove the progress sentinel
1879		if ( fn === "inprogress" ) {
1880			fn = queue.shift();
1881			startLength--;
1882		}
1883
1884		if ( fn ) {
1885
1886			// Add a progress sentinel to prevent the fx queue from being
1887			// automatically dequeued
1888			if ( type === "fx" ) {
1889				queue.unshift( "inprogress" );
1890			}
1891
1892			// clear up the last queue stop function
1893			delete hooks.stop;
1894			fn.call( elem, next, hooks );
1895		}
1896
1897		if ( !startLength && hooks ) {
1898			hooks.empty.fire();
1899		}
1900	},
1901
1902	// not intended for public consumption - generates a queueHooks object, or returns the current one
1903	_queueHooks: function( elem, type ) {
1904		var key = type + "queueHooks";
1905		return jQuery._data( elem, key ) || jQuery._data( elem, key, {
1906			empty: jQuery.Callbacks("once memory").add(function() {
1907				jQuery.removeData( elem, type + "queue", true );
1908				jQuery.removeData( elem, key, true );
1909			})
1910		});
1911	}
1912});
1913
1914jQuery.fn.extend({
1915	queue: function( type, data ) {
1916		var setter = 2;
1917
1918		if ( typeof type !== "string" ) {
1919			data = type;
1920			type = "fx";
1921			setter--;
1922		}
1923
1924		if ( arguments.length < setter ) {
1925			return jQuery.queue( this[0], type );
1926		}
1927
1928		return data === undefined ?
1929			this :
1930			this.each(function() {
1931				var queue = jQuery.queue( this, type, data );
1932
1933				// ensure a hooks for this queue
1934				jQuery._queueHooks( this, type );
1935
1936				if ( type === "fx" && queue[0] !== "inprogress" ) {
1937					jQuery.dequeue( this, type );
1938				}
1939			});
1940	},
1941	dequeue: function( type ) {
1942		return this.each(function() {
1943			jQuery.dequeue( this, type );
1944		});
1945	},
1946	// Based off of the plugin by Clint Helfers, with permission.
1947	

1947delay: function( time, type ) {
1948		time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
1949		type = type || "fx";
1950
1951		return this.queue( type, function( next, hooks ) {
1952			var timeout = setTimeout( next, time );
1953			hooks.stop = function() {
1954				clearTimeout( timeout );
1955			};
1956		});
1957	},
1958	clearQueue: function( type ) {
1959		return this.queue( type || "fx", [] );
1960	},
1961	// Get a promise resolved when queues of a certain type
1962	// are emptied (fx is the type by default)
1963	promise: function( type, obj ) {
1964		var tmp,
1965			count = 1,
1966			defer = jQuery.Deferred(),
1967			elements = this,
1968			i = this.length,
1969			resolve = function() {
1970				if ( !( --count ) ) {
1971					defer.resolveWith( elements, [ elements ] );
1972				}
1973			};
1974
1975		if ( typeof type !== "string" ) {
1976			obj = type;
1977			type = undefined;
1978		}
1979		type = type || "fx";
1980
1981		while( i-- ) {
1982			tmp = jQuery._data( elements[ i ], type + "queueHooks" );
1983			if ( tmp && tmp.empty ) {
1984				count++;
1985				tmp.empty.add( resolve );
1986			}
1987		}
1988		resolve();
1989		return defer.promise( obj );
1990	}
1991});
1992var nodeHook, boolHook, fixSpecified,
1993	rclass = /[\t\r\n]/g,
1994	rreturn = /\r/g,
1995	rtype = /^(?:button|input)$/i,
1996	rfocusable = /^(?:button|input|object|select|textarea)$/i,
1997	rclickable = /^a(?:rea|)$/i,
1998	rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
1999	getSetAttribute = jQuery.support.getSetAttribute;
2000
2001jQuery.fn.extend({
2002	attr: function( name, value ) {
2003		return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
2004	},
2005
2006	removeAttr: function( name ) {
2007		return this.each(function() {
2008			jQuery.removeAttr( this, name );
2009		});
2010	},
2011
2012	prop: function( name, value ) {
2013		return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
2014	},
2015
2016	removeProp: function( name ) {
2017		name = jQuery.propFix[ name ] || name;
2018		return this.each(function() {
2019			// try/catch handles cases where IE balks (such as removing a property on window)
2020			try {
2021				this[ name ] = undefined;
2022				delete this[ name ];
2023			} catch( e ) {}
2024		});
2025	},
2026
2027	addClass: function( value ) {
2028		var classNames, i, l, elem,
2029			setClass, c, cl;
2030
2031		if ( jQuery.isFunction( value ) ) {
2032			return this.each(function( j ) {
2033				jQuery( this ).addClass( value.call(this, j, this.className) );
2034			});
2035		}
2036
2037		if ( value && typeof value === "string" ) {
2038			classNames = value.split( core_rspace );
2039
2040			for ( i = 0, l = this.length; i < l; i++ ) {
2041				elem = this[ i ];
2042
2043				if ( elem.nodeType === 1 ) {
2044					if ( !elem.className && classNames.length === 1 ) {
2045						elem.className = value;
2046
2047					} else {
2048						setClass = " " + elem.className + " ";
2049
2050						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2051							if ( setClass.indexOf( " " + classNames[ c ] + " " ) < 0 ) {
2052								setClass += classNames[ c ] + " ";
2053							}
2054						}
2055						elem.className = jQuery.trim( setClass );
2056					}
2057				}
2058			}
2059		}
2060
2061		return this;
2062	},
2063
2064	removeClass: function( value ) {
2065		var removes, className, elem, c, cl, i, l;
2066
2067		if ( jQuery.isFunction( value ) ) {
2068			return this.each(function( j ) {
2069				jQuery( this ).removeClass( value.call(this, j, this.className) );
2070			});
2071		}
2072		if ( (value && typeof value === "string") || value === undefined ) {
2073			removes = ( value || "" ).split( core_rspace );
2074
2075			for ( i = 0, l = this.length; i < l; i++ ) {
2076				elem = this[ i ];
2077				if ( elem.nodeType === 1 && elem.className ) {
2078
2079					className = (" " + elem.className + " ").replace( rclass, " " );
2080
2081					// loop over each item in the removal list
2082					for ( c = 0, cl = removes.length; c < cl; c++ ) {
2083						// Remove until there is nothing to remove,
2084						while ( className.indexOf(" " + removes[ c ] + " ") >= 0 ) {
2085							className = className.replace( " " + removes[ c ] + " " , " " );
2086						}
2087					}
2088					elem.className = value ? jQuery.trim( className ) : "";
2089				}
2090			}
2091		}
2092
2093		return this;
2094	},
2095
2096	toggleClass: function( value, stateVal ) {
2097		var type = typeof value,
2098			isBool = typeof stateVal === "boolean";
2099
2100		if ( jQuery.isFunction( value ) ) {
2101			return this.each(function( i ) {
2102				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
2103			});
2104		}
2105
2106		return this.each(function() {
2107			if ( type === "string" ) {
2108				// toggle individual class names
2109				var className,
2110					i = 0,
2111					self = jQuery( this ),
2112					state = stateVal,
2113					classNames = value.split( core_rspace );
2114
2115				while ( (className = classNames[ i++ ]) ) {
2116					// check each className given, space separated list
2117					state = isBool ? state : !self.hasClass( className );
2118					self[ state ? "addClass" : "removeClass" ]( className );
2119				}
2120
2121			} else if ( type === "undefined" || type === "boolean" ) {
2122				if ( this.className ) {
2123					// store className if set
2124					jQuery._data( this, "__className__", this.className );
2125				}
2126
2127				// toggle whole className
2128				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2129			}
2130		});
2131	},
2132
2133	hasClass: function( selector ) {
2134		var className = " " + selector + " ",
2135			i = 0,
2136			l = this.length;
2137		for ( ; i < l; i++ ) {
2138			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
2139				return true;
2140			}
2141		}
2142
2143		return false;
2144	},
2145
2146	val: function( value ) {
2147		var hooks, ret, isFunction,
2148			elem = this[0];
2149
2150		if ( !arguments.length ) {
2151			if ( elem ) {
2152				hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
2153
2154				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2155					return ret;
2156				}
2157
2158				ret = elem.value;
2159
2160				return typeof ret === "string" ?
2161					// handle most common string cases
2162					ret.replace(rreturn, "") :
2163					// handle cases where value is null/undef or number
2164					ret == null ? "" : ret;
2165			}
2166
2167			return;
2168		}
2169
2170		isFunction = jQuery.isFunction( value );
2171
2172		return this.each(function( i ) {
2173			var val,
2174				self = jQuery(this);
2175
2176			if ( this.nodeType !== 1 ) {
2177				return;
2178			}
2179
2180			if ( isFunction ) {
2181				val = value.call( this, i, self.val() );
2182			} else {
2183				val = value;
2184			}
2185
2186			// Treat null/undefined as ""; convert numbers to string
2187			if ( val == null ) {
2188				val = "";
2189			} else if ( typeof val === "number" ) {
2190				val += "";
2191			} else if ( jQuery.isArray( val ) ) {
2192				val = jQuery.map(val, function ( value ) {
2193					return value == null ? "" : value + "";
2194				});
2195			}
2196
2197			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
2198
2199			// If set returns undefined, fall back to normal setting
2200			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
2201				this.value = val;
2202			}
2203		});
2204	}
2205});
2206
2207jQuery.extend({
2208	valHooks: {
2209		option: {
2210			get: function( elem ) {
2211				// attributes.value is undefined in Blackberry 4.7 but
2212				// uses .value. See #6932
2213				var val = elem.attributes.value;
2214				return !val || val.specified ? elem.value : elem.text;
2215			}
2216		},
2217		select: {
2218			get: function( elem ) {
2219				var value, i, max, option,
2220					index = elem.selectedIndex,
2221					values = [],
2222					options = elem.options,
2223					one = elem.type === "select-one";
2224
2225				// Nothing was selected
2226				if ( index < 0 ) {
2227					return null;
2228				}
2229
2230				// Loop through all the selected options
2231				i = one ? index : 0;
2232				max = one ? index + 1 : options.length;
2233				for ( ; i < max; i++ ) {
2234					option = options[ i ];
2235
2236					// Don't return options that are disabled or in a disabled optgroup
2237					if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2238							(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
2239
2240						// Get the specific value for the option
2241						value = jQuery( option ).val();
2242
2243						// We don't need an array for one selects
2244						if ( one ) {
2245							return value;
2246						}
2247
2248						// Multi-Selects return an array
2249						values.push( value );
2250					}
2251				}
2252
2253				// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2254				if ( one && !values.length && options.length ) {
2255					return jQuery( options[ index ] ).val();

2255
2256				}
2257
2258				return values;
2259			},
2260
2261			set: function( elem, value ) {
2262				var values = jQuery.makeArray( value );
2263
2264				jQuery(elem).find("option").each(function() {
2265					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2266				});
2267
2268				if ( !values.length ) {
2269					elem.selectedIndex = -1;
2270				}
2271				return values;
2272			}
2273		}
2274	},
2275
2276	// Unused in 1.8, left in so attrFn-stabbers won't die; remove in 1.9
2277	attrFn: {},
2278
2279	attr: function( elem, name, value, pass ) {
2280		var ret, hooks, notxml,
2281			nType = elem.nodeType;
2282
2283		// don't get/set attributes on text, comment and attribute nodes
2284		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2285			return;
2286		}
2287
2288		if ( pass && jQuery.isFunction( jQuery.fn[ name ] ) ) {
2289			return jQuery( elem )[ name ]( value );
2290		}
2291
2292		// Fallback to prop when attributes are not supported
2293		if ( typeof elem.getAttribute === "undefined" ) {
2294			return jQuery.prop( elem, name, value );
2295		}
2296
2297		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2298
2299		// All attributes are lowercase
2300		// Grab necessary hook if one is defined
2301		if ( notxml ) {
2302			name = name.toLowerCase();
2303			hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
2304		}
2305
2306		if ( value !== undefined ) {
2307
2308			if ( value === null ) {
2309				jQuery.removeAttr( elem, name );
2310				return;
2311
2312			} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2313				return ret;
2314
2315			} else {
2316				elem.setAttribute( name, value + "" );
2317				return value;
2318			}
2319
2320		} else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
2321			return ret;
2322
2323		} else {
2324
2325			ret = elem.getAttribute( name );
2326
2327			// Non-existent attributes return null, we normalize to undefined
2328			return ret === null ?
2329				undefined :
2330				ret;
2331		}
2332	},
2333
2334	removeAttr: function( elem, value ) {
2335		var propName, attrNames, name, isBool,
2336			i = 0;
2337
2338		if ( value && elem.nodeType === 1 ) {
2339
2340			attrNames = value.split( core_rspace );
2341
2342			for ( ; i < attrNames.length; i++ ) {
2343				name = attrNames[ i ];
2344
2345				if ( name ) {
2346					propName = jQuery.propFix[ name ] || name;
2347					isBool = rboolean.test( name );
2348
2349					// See #9699 for explanation of this approach (setting first, then removal)
2350					// Do not do this for boolean attributes (see #10870)
2351					if ( !isBool ) {
2352						jQuery.attr( elem, name, "" );
2353					}
2354					elem.removeAttribute( getSetAttribute ? name : propName );
2355
2356					// Set corresponding property to false for boolean attributes
2357					if ( isBool && propName in elem ) {
2358						elem[ propName ] = false;
2359					}
2360				}
2361			}
2362		}
2363	},
2364
2365	attrHooks: {
2366		type: {
2367			set: function( elem, value ) {
2368				// We can't allow the type property to be changed (since it causes problems in IE)
2369				if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
2370					jQuery.error( "type property can't be changed" );
2371				} else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2372					// Setting the type on a radio button after the value resets the value in IE6-9
2373					// Reset value to it's default in case type is set after value
2374					// This is for element creation
2375					var val = elem.value;
2376					elem.setAttribute( "type", value );
2377					if ( val ) {
2378						elem.value = val;
2379					}
2380					return value;
2381				}
2382			}
2383		},
2384		// Use the value property for back compat
2385		// Use the nodeHook for button elements in IE6/7 (#1954)
2386		value: {
2387			get: function( elem, name ) {
2388				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2389					return nodeHook.get( elem, name );
2390				}
2391				return name in elem ?
2392					elem.value :
2393					null;
2394			},
2395			set: function( elem, value, name ) {
2396				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2397					return nodeHook.set( elem, value, name );
2398				}
2399				// Does not return so that setAttribute is also used
2400				elem.value = value;
2401			}
2402		}
2403	},
2404
2405	propFix: {
2406		tabindex: "tabIndex",
2407		readonly: "readOnly",
2408		"for": "htmlFor",
2409		"class": "className",
2410		maxlength: "maxLength",
2411		cellspacing: "cellSpacing",
2412		cellpadding: "cellPadding",
2413		rowspan: "rowSpan",
2414		colspan: "colSpan",
2415		usemap: "useMap",
2416		frameborder: "frameBorder",
2417		contenteditable: "contentEditable"
2418	},
2419
2420	prop: function( elem, name, value ) {
2421		var ret, hooks, notxml,
2422			nType = elem.nodeType;
2423
2424		// don't get/set properties on text, comment and attribute nodes
2425		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2426			return;
2427		}
2428
2429		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2430
2431		if ( notxml ) {
2432			// Fix name and attach hooks
2433			name = jQuery.propFix[ name ] || name;
2434			hooks = jQuery.propHooks[ name ];
2435		}
2436
2437		if ( value !== undefined ) {
2438			if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2439				return ret;
2440
2441			} else {
2442				return ( elem[ name ] = value );
2443			}
2444
2445		} else {
2446			if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
2447				return ret;
2448
2449			} else {
2450				return elem[ name ];
2451			}
2452		}
2453	},
2454
2455	propHooks: {
2456		tabIndex: {
2457			get: function( elem ) {
2458				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2459				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2460				var attributeNode = elem.getAttributeNode("tabindex");
2461
2462				return attributeNode && attributeNode.specified ?
2463					parseInt( attributeNode.value, 10 ) :
2464					rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
2465						0 :
2466						undefined;
2467			}
2468		}
2469	}
2470});
2471
2472// Hook for boolean attributes
2473boolHook = {
2474	get: function( elem, name ) {
2475		// Align boolean attributes with corresponding properties
2476		// Fall back to attribute presence where some booleans are not supported
2477		var attrNode,
2478			property = jQuery.prop( elem, name );
2479		return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
2480			name.toLowerCase() :
2481			undefined;
2482	},
2483	set: function( elem, value, name ) {
2484		var propName;
2485		if ( value === false ) {
2486			// Remove boolean attributes when set to false
2487			jQuery.removeAttr( elem, name );
2488		} else {
2489			// value is true since we know at this point it's type boolean and not false
2490			// Set boolean attributes to the same name and set the DOM property
2491			propName = jQuery.propFix[ name ] || name;
2492			if ( propName in elem ) {
2493				// Only set the IDL specifically if it already exists on the element
2494				elem[ propName ] = true;
2495			}
2496
2497			elem.setAttribute( name, name.toLowerCase() );
2498		}
2499		return name;
2500	}
2501};
2502
2503// IE6/7 do not support getting/setting some attributes with get/setAttribute
2504if ( !getSetAttribute ) {
2505
2506	fixSpecified = {
2507		name: true,
2508		id: true,
2509		coords: true
2510	};
2511
2512	// Use this for any attribute in IE6/7
2513	// This fixes almost every IE6/7 issue
2514	nodeHook = jQuery.valHooks.button = {
2515		get: function( elem, name ) {
2516			var ret;
2517			ret = elem.getAttributeNode( name );
2518			return ret && ( fixSpecified[ name ] ? ret.value !== "" : ret.specified ) ?
2519				ret.value :
2520				undefined;
2521		},
2522		set: function( elem, value, name ) {
2523			// Set the existing or create a new attribute node
2524			var ret = elem.getAttributeNode( name );
2525			if ( !ret ) {
2526				ret = document.createAttribute( name );
2527				elem.setAttributeNode( ret );
2528			}
2529			return ( ret.value = value + "" );
2530		}
2531	};
2532
2533	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
2534	// This is for removals
2535	jQuery.each([ "width", "height" ], function( i, name ) {
2536		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2537			set: function( elem, value ) {
2538				if ( value === "" ) {
2539					elem.setAttribute( name, "auto" );
2540					return value;
2541				}
2542			}
2543		});
2544	});
2545
2546	// Set contenteditable to false on removals(#10429)
2547	// Setting to empty string throws an error as an invalid value
2548	jQuery.attrHooks.contenteditable = {
2549		get: nodeHook.get,
2550		set: function( elem, value, name ) {
2551			if ( value === "" ) {
2552				value = "false";
2553			}
2554			nodeHook.set( elem, value, name );
2555		}
2556	};
2557}
2558
2559
2560// Some attributes require a special call on IE
2561if ( !jQuery.support.hrefNormalized ) {
2562	jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
2563		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2564			get: function( elem ) {
2565				var ret = elem.getAttribute( name, 2 );
2566				return ret === null ? undefined : ret;
2567			}
2568		});
2569	});
2570}
2571
2572if ( !jQuery.support.style ) {
2573	jQuery.attrHooks.style = {
2574		get: function( elem ) {
2575			// Return undefined in the case of empty string
2576			// Normalize to lowercase since IE uppercases css property names
2577			return elem.style.cssText.toLowerCase() || undefined;
2578		},
2579		set: function( elem, value ) {
2580			return ( elem.style.cssText = value + "" );
2581		}
2582	};
2583}
2584
2585// Safari mis-reports the default selected property of an option
2586// Accessing the parent's selectedIndex property fixes it
2587if ( !jQuery.support.optSelected ) {
2588	jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
2589		get: function( elem ) {
2590			var parent = elem.parentNode;
2591
2592			if ( parent ) {
2593				parent.selectedIndex;
2594
2595				// Make sure that it also works with optgroups, see #5701
2596				if ( parent.parentNode ) {
2597					parent.parentNode.selectedIndex;
2598				}
2599			}
2600			return null;
2601		}
2602	});
2603}
2604
2605// IE6/7 call enctype encoding
2606if ( !jQuery.support.enctype ) {
2607	jQuery.propFix.enctype = "encoding";
2608}
2609
2610// Radios and checkboxes getter/setter
2611if ( !jQuery.support.checkOn ) {
2612	jQuery.each([ "radio", "checkbox" ], function() {
2613		jQuery.valHooks[ this ] = {
2614			get: function( elem ) {
2615				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2616				return elem.getAttribute("value") === null ? "on" : elem.value;
2617			}
2618		};
2619	});
2620}
2621jQuery.each([ "radio", "checkbox" ], function() {
2622	jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2623		set: function( elem, value ) {
2624			if ( jQuery.isArray( value ) ) {
2625				return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
2626			}
2627		}
2628	});
2629});
2630var rformElems = /^(?:textarea|input|select)$/i,
2631	rtypenamespace = /^([^\.]*|)(?:\.(.+)|)$/,
2632	rhoverHack = /(?:^|\s)hover(\.\S+|)\b/,
2633	rkeyEvent = /^key/,
2634	rmouseEvent = /^(?:mouse|contextmenu)|click/,
2635	rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
2636	hoverHack = function( events ) {
2637		return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
2638	};
2639
2640/*
2641 * Helper functions for managing events -- not part of the public interface.
2642 * Props to Dean Edwards' addEvent library for many of the ideas.
2643 */
2644jQuery.event = {
2645
2646	add: function( elem, types, handler, data, selector ) {
2647
2648		var elemData, eventHandle, events,
2649			t, tns, type, namespaces, handleObj,
2650			handleObjIn, handlers, special;
2651
2652		// Don't attach events to noData or text/comment nodes (allow plain objects tho)
2653		if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
2654			return;
2655		}
2656
2657		// Caller can pass in an object of custom data in lieu of the handler
2658		if ( handler.handler ) {
2659			handleObjIn = handler;
2660			handler = handleObjIn.handler;
2661			selector = handleObjIn.selector;
2662		}
2663
2664		// Make sure that the handler has a unique ID, used to find/remove it later
2665		if ( !handler.guid ) {
2666			handler.guid = jQuery.guid++;
2667		}
2668
2669		// Init the element's event structure and main handler, if this is the first
2670		events = elemData.events;
2671		if ( !events ) {
2672			elemData.events = events = {};
2673		}
2674		eventHandle = elemData.handle;
2675		if ( !eventHandle ) {
2676			elemData.handle = eventHandle = function( e ) {
2677				// Discard the second event of a jQuery.event.trigger() and
2678				// when an event is called after a page has unloaded
2679				return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
2680					jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
2681					undefined;
2682			};
2683			// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
2684			eventHandle.elem = elem;
2685		}
2686
2687		// Handle multiple events separated by a space
2688		// jQuery(...).bind("mouseover mouseout", fn);
2689		types = jQuery.trim( hoverHack(types) ).split( " " );
2690		for ( t = 0; t < types.length; t++ ) {
2691
2692			tns = rtypenamespace.exec( types[t] ) || [];
2693			type = tns[1];
2694			namespaces = ( tns[2] || "" ).split( "." ).sort();
2695
2696			// If event changes its type, use the special event handlers for the changed type
2697			special = jQuery.event.special[ type ] || {};
2698
2699			// If selector defined, determine special event api type, otherwise given type
2700			type = ( selector ? special.delegateType : special.bindType ) || type;
2701
2702			// Update special based on newly reset type
2703			special = jQuery.event.special[ type ] || {};
2704
2705			// handleObj is passed to all event handlers
2706			handleObj = jQuery.extend({
2707				type: type,
2708				origType: tns[1],
2709				data: data,
2710				handler: handler,
2711				guid: handler.guid,
2712				selector: selector,
2713				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
2714				namespace: namespaces.join(".")
2715			}, handleObjIn );
2716
2717			// Init the event handler queue if we're the first
2718			handlers = events[ type ];
2719			if ( !handlers ) {
2720				handlers = events[ type ] = [];
2721				handlers.delegateCount = 0;
2722
2723				// Only use addEventListener/attachEvent if the special events handler returns false
2724				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2725					// Bind the global event handler to the element
2726					if ( elem.addEventListener ) {
2727						elem.addEventListener( type, eventHandle, false );
2728
2729					} else if ( elem.attachEvent ) {
2730						elem.attachEvent( "on" + type, eventHandle );
2731					}
2732				}
2733			}
2734
2735			if ( special.add ) {
2736				special.add.call( elem, handleObj );
2737
2738				if ( !handleObj.handler.guid ) {
2739					handleObj.handler.guid = handler.guid;
2740				}
2741			}
2742
2743			// Add to the element's handler list, delegates in front
2744			if ( selector ) {
2745				handlers.splice( handlers.delegateCount++, 0, handleObj );
2746			} else {
2747				handlers.push( handleObj );
2748			}
2749
2750			// Keep track of which events have ever been used, for event optimization
2751			jQuery.event.global[ type ] = true;
2752		}
2753
2754		// Nullify elem to prevent memory leaks in IE
2755		elem = null;
2756	},
2757
2758	global: {},
2759
2760	// Detach an event or set of events from an element
2761	remove: function( elem, types, handler, selector, mappedTypes ) {
2762
2763		var t, tns, type, origType, namespaces, origCount,
2764			j, events, special, eventType, handleObj,
2765			elemData = jQuery.hasData( elem ) && jQuery._data( elem );
2766
2767		if ( !elemData || !(events = elemData.events) ) {
2768			return;
2769		}
2770
2771		// Once for each type.namespace in types; type may be omitted
2772		types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
2773		for ( t = 0; t < types.length; t++ ) {
2774			tns = rtypenamespace.exec( types[t] ) || [];
2775			type = origType = tns[1];
2776			namespaces = tns[2];
2777
2778			// Unbind all events (on this namespace, if provided) for the element
2779			if ( !type ) {
2780				for ( type in events ) {
2781					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
2782				}
2783				continue;
2784			}
2785
2786			special = jQuery.event.special[ type ] || {};
2787			type = ( selector? special.delegateType : special.bindType ) || type;
2788			eventType = events[ type ] || [];
2789			origCount = eventType.length;
2790			namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
2791
2792			// Remove matching events
2793			for ( j = 0; j < eventType.length; j++ ) {
2794				handleObj = eventType[ j ];
2795
2796				if ( ( mappedTypes || origType === handleObj.origType ) &&
2797					 ( !handler || handler.guid === handleObj.guid ) &&
2798					 ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
2799					 ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
2800					eventType.splice( j--, 1 );
2801
2802					if ( handleObj.selector ) {
2803						eventType.delegateCount--;
2804					}
2805					if ( special.remove ) {
2806						special.remove.call( elem, handleObj );
2807					}
2808				}
2809			}
2810
2811			// Remove generic event handler if we removed something and no more handlers exist
2812			// (avoids potential for endless recursion during removal of special event handlers)
2813			if ( eventType.length === 0 && origCount !== eventType.length ) {
2814				if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
2815					jQuery.removeEvent( elem, type, elemData.handle );
2816				}
2817
2818				delete events[ type ];
2819			}
2820		}
2821
2822		// Remove the expando if it's no longer used
2823		if ( jQuery.isEmptyObject( events ) ) {
2824			delete elemData.handle;
2825
2826			// removeData also checks for emptiness and clears the expando if empty
2827			// so use it instead of delete
2828			jQuery.removeData( elem, "events", true );
2829		}
2830	},
2831
2832	// Events that are safe to short-circuit if no handlers are attached.
2833	// Native DOM events should not be added, they may have inline handlers.
2834	customEvent: {
2835		"getData": true,
2836		"setData": true,
2837		"changeData": true
2838	},
2839
2840	trigger: function( event, data, elem, onlyHandlers ) {
2841		// Don't do events on text and comment nodes
2842		if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
2843			return;
2844		}
2845
2846		// Event object or event type
2847		var cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType,
2848			type = event.type || event,
2849			namespaces = [];
2850
2851		// focus/blur morphs to focusin/out; ensure we're not firing them right now
2852		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
2853			return;
2854		}
2855
2856		if ( type.indexOf( "!" ) >= 0 ) {
2857			// Exclusive events trigger only for the exact event (no namespaces)
2858			type = type.slice(0, -1);
2859			exclusive = true;
2860		}
2861
2862		if ( type.indexOf( "." ) >= 0 ) {
2863			// Namespaced trigger; create a regexp to match event type in handle()
2864			namespaces = type.split(".");
2865			type = namespaces.shift();
2866			namespaces.sort();
2867		}
2868
2869		if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
2870			// No jQuery handlers for this event type, and it can't have inline handlers
2871			return;
2872		}
2873
2874		// Caller can pass in an Event, Object, or just an event type string
2875		event = typeof event === "object" ?
2876			// jQuery.Event object
2877			event[ jQuery.expando ] ? event :
2878			// Object literal
2879			new jQuery.Event( type, event ) :
2880			// Just the event type (string)
2881			new jQuery.Event( type );
2882
2883		event.type = type;
2884		event.isTrigger = true;
2885		event.exclusive = exclusive;
2886		event.namespace = namespaces.join( "." );
2887		event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
2888		ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
2889
2890		// Handle a global trigger
2891		if ( !elem ) {
2892
2893			// TODO: Stop taunting the data cache; remove global events and always attach to document
2894			cache = jQuery.cache;
2895			for ( i in cache ) {
2896				if ( cache[ i ].events && cache[ i ].events[ type ] ) {
2897					jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
2898				}
2899			}
2900			return;
2901		}
2902
2903		// Clean up the event in case it is being reused
2904		event.result = undefined;
2905		if ( !event.target ) {
2906			event.target = elem;
2907		}
2908
2909		// Clone any incoming data and prepend the event, creating the handler arg list
2910		data = data != null ? jQuery.makeArray( data ) : [];
2911		data.unshift( event );
2912
2913		// Allow special events to draw outside the lines
2914		special = jQuery.event.special[ type ] || {};
2915		if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
2916			return;
2917		}
2918
2919		// Determine event propagation path in advance, per W3C events spec (#9951)
2920		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
2921		eventPath = [[ elem, special.bindType || type ]];
2922		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
2923
2924			bubbleType = special.delegateType || type;
2925			cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
2926			for ( old = elem; cur; cur = cur.parentNode ) {
2927				eventPath.push([ cur, bubbleType ]);
2928				old = cur;
2929			}
2930
2931			// Only add window if we got to document (e.g., not plain obj or detached DOM)
2932			if ( old === (elem.ownerDocument || document) ) {
2933				eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
2934			}
2935		}
2936
2937		// Fire handlers on the event path
2938		for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
2939
2940			cur = eventPath[i][0];
2941			event.type = eventPath[i][1];
2942
2943			handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
2944			if ( handle ) {
2945				handle.apply( cur, data );
2946			}
2947			// Note that this is a bare JS function and not a jQuery handler
2948			handle = ontype && cur[ ontype ];
2949			if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) {
2950				event.preventDefault();
2951			}
2952		}
2953		event.type = type;
2954
2955		// If nobody prevented the default action, do it now
2956		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
2957
2958			if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
2959				!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
2960
2961				// Call a native DOM method on the target with the same name name as the event.
2962				// Can't use an .isFunction() check here because IE6/7 fails that test.
2963				// Don't do default actions on window, that's where global variables be (#6170)
2964				// IE<9 dies on focus/blur to hidden element (#1486)
2965				if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
2966
2967					// Don't re-trigger an onFOO event when we call its FOO() method
2968					old = elem[ ontype ];
2969
2970					if ( old ) {
2971						elem[ ontype ] = null;
2972					}
2973
2974					// Prevent re-triggering of the same event, since we already bubbled it above
2975					jQuery.event.triggered = type;
2976					elem[ type ]();
2977					jQuery.event.triggered = undefined;
2978
2979					if ( old ) {
2980						elem[ ontype ] = old;
2981					}
2982				}
2983			}
2984		}
2985
2986		return event.result;
2987	},
2988
2989	dispatch: function( event ) {
2990
2991		// Make a writable jQuery.Event from the native event object
2992		event = jQuery.event.fix( event || window.event );
2993
2994		var i, j, cur, ret, selMatch, matched, matches, handleObj, sel, related,
2995			handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
2996			delegateCount = handlers.delegateCount,
2997			args = core_slice.call( arguments ),
2998			run_all = !event.exclusive && !event.namespace,
2999			special = jQuery.event.special[ event.type ] || {},
3000			handlerQueue = [];
3001
3002		// Use the fix-ed jQuery.Event rather than the (read-only) native event
3003		args[0] = event;
3004		event.delegateTarget = this;
3005
3006		// Call the preDispatch hook for the mapped type, and let it bail if desired
3007		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
3008			return;
3009		}
3010
3011		// Determine handlers that should run if there are delegated events
3012		// Avoid non-left-click bubbling in Firefox (#3861)
3013		if ( delegateCount && !(event.button && event.type === "click") ) {
3014
3015			for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
3016
3017				// Don't process clicks (ONLY) on disabled elements (#6911, #8165, #11382, #11764)
3018				if ( cur.disabled !== true || event.type !== "click" ) {
3019					selMatch = {};
3020					matches = [];
3021					for ( i = 0; i < delegateCount; i++ ) {
3022						handleObj = handlers[ i ];
3023						sel = handleObj.selector;
3024
3025						if ( selMatch[ sel ] === undefined ) {
3026							selMatch[ sel ] = handleObj.needsContext ?
3027								jQuery( sel, this ).index( cur ) >= 0 :
3028								jQuery.find( sel, this, null, [ cur ] ).length;
3029						}
3030						if ( selMatch[ sel ] ) {
3031							matches.push( handleObj );
3032						}
3033					}
3034					if ( matches.length ) {
3035						handlerQueue.push({ elem: cur, matches: matches });
3036					}
3037				}
3038			}
3039		}
3040
3041		// Add the remaining (directly-bound) handlers
3042		if ( handlers.length > delegateCount ) {
3043			handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
3044		}
3045
3046		// Run delegates first; they may want to stop propagation beneath us
3047		for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
3048			matched = handlerQueue[ i ];
3049			event.currentTarget = matched.elem;
3050
3051			for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
3052				handleObj = matched.matches[ j ];
3053
3054				// Triggered event must either 1) be non-exclusive and have no namespace, or
3055				// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
3056				if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
3057
3058					event.data = handleObj.data;
3059					event.handleObj = handleObj;
3060
3061					ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
3062							.apply( matched.elem, args );
3063
3064					if ( ret !== undefined ) {
3065						event.result = ret;
3066						if ( ret === false ) {
3067							event.preventDefault();
3068							event.stopPropagation();
3069						}
3070					}
3071				}
3072			}
3073		}
3074
3075		// Call the postDispatch hook for the mapped type
3076		if ( special.postDispatch ) {
3077			special.postDispatch.call( this, event );
3078		}
3079
3080		return event.result;
3081	},
3082
3083	// Includes some event props shared by KeyEvent and MouseEvent
3084	// *** attrChange attrName relatedNode srcElement  are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
3085	props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
3086
3087	fixHooks: {},
3088
3089	keyHooks: {
3090		props: "char charCode key keyCode".split(" "),
3091		filter: function( event, original ) {
3092
3093			// Add which for key events
3094			if ( event.which == null ) {
3095				event.which = original.charCode != null ? original.charCode : original.keyCode;
3096			}
3097
3098			return event;
3099		}
3100	},
3101
3102	mouseHooks: {
3103		props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
3104		filter: function( event, original ) {
3105			var eventDoc, doc, body,
3106				button = original.button,
3107				fromElement = original.fromElement;
3108
3109			// Calculate pageX/Y if missing and clientX/Y available
3110			if ( event.pageX == null && original.clientX != null ) {
3111				eventDoc = event.target.ownerDocument || document;
3112				doc = eventDoc.documentElement;
3113				body = eventDoc.body;
3114
3115				event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
3116				event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
3117			}
3118
3119			// Add relatedTarget, if necessary
3120			if ( !event.relatedTarget && fromElement ) {
3121				event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
3122			}
3123
3124			// Add which for click: 1 === left; 2 === middle; 3 === right
3125			// Note: button is not normalized, so don't use it
3126			if ( !event.which && button !== undefined ) {
3127				event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
3128			}
3129
3130			return event;
3131		}
3132	},
3133
3134	fix: function( event ) {
3135		if ( event[ jQuery.expando ] ) {
3136			return event;
3137		}
3138
3139		// Create a writable copy of the event object and normalize some properties
3140		var i, prop,
3141			originalEvent = event,
3142			fixHook = jQuery.event.fixHooks[ event.type ] || {},
3143			copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
3144
3145		event = jQuery.Event( originalEvent );
3146
3147		for ( i = copy.length; i; ) {
3148			prop = copy[ --i ];
3149			event[ prop ] = originalEvent[ prop ];
3150		}
3151
3152		// Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
3153		if ( !event.target ) {
3154			event.target = originalEvent.srcElement || document;
3155		}
3156
3157		// Target should not be a text node (#504, Safari)
3158		if ( event.target.nodeType === 3 ) {
3159			event.target = event.target.parentNode;
3160		}
3161
3162		// For mouse/key events, metaKey==false if it's undefined (#3368, #11328; IE6/7/8)
3163		event.metaKey = !!event.metaKey;
3164
3165		return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
3166	},
3167
3168	special: {
3169		load: {
3170			// Prevent triggered image.load events from bubbling to window.load
3171			noBubble: true
3172		},
3173
3174		focus: {
3175			delegateType: "focusin"
3176		},
3177		blur: {
3178			delegateType: "focusout"
3179		},
3180
3181		beforeunload: {
3182			setup: function( data, namespaces, eventHandle ) {
3183				// We only want to do this special case on windows
3184				if ( jQuery.isWindow( this ) ) {
3185					this.onbeforeunload = eventHandle;
3186				}
3187			},
3188
3189			teardown: function( namespaces, eventHandle ) {
3190				if ( this.onbeforeunload === eventHandle ) {
3191					this.onbeforeunload = null;
3192				}
3193			}
3194		}
3195	},
3196
3197	simulate: function( type, elem, event, bubble ) {
3198		// Piggyback on a donor event to simulate a different one.
3199		// Fake originalEvent to avoid donor's stopPropagation, but if the
3200		// simulated event prevents default then we do the same on the donor.
3201		var e = jQuery.extend(
3202			new jQuery.Event(),
3203			event,
3204			{ type: type,
3205				isSimulated: true,
3206				originalEvent: {}
3207			}
3208		);
3209		if ( bubble ) {
3210			jQuery.event.trigger( e, null, elem );
3211		} else {
3212			jQuery.event.dispatch.call( elem, e );
3213		}
3214		if ( e.isDefaultPrevented() ) {
3215			event.preventDefault();
3216		}
3217	}
3218};
3219
3220// Some plugins are using, but it's undocumented/deprecated and will be removed.
3221// The 1.7 special event interface should provide all the hooks needed now.
3222jQuery.event.handle = jQuery.event.dispatch;
3223
3224jQuery.removeEvent = document.removeEventListener ?
3225	function( elem, type, handle ) {
3226		if ( elem.removeEventListener ) {
3227			elem.removeEventListener( type, handle, false );
3228		}
3229	} :
3230	function( elem, type, handle ) {
3231		var name = "on" + type;
3232
3233		if ( elem.detachEvent ) {
3234
3235			// #8545, #7054, preventing memory leaks for custom events in IE6-8