http://hylmuseum.cn/templates/specialty/js/jquery.js

1(function( window, undefined ) {
2
3// Use the correct document accordingly with window argument (sandbox)
4var document = window.document,
5	navigator = window.navigator,
6	location = window.location;
7var jQuery = (function() {
8
9// Define a local copy of jQuery
10var jQuery = function( selector, context ) {
11		// The jQuery object is actually just the init constructor 'enhanced'
12		return new jQuery.fn.init( selector, context, rootjQuery );
13	},
14
15	// Map over jQuery in case of overwrite
16	_jQuery = window.jQuery,
17
18	// Map over the $ in case of overwrite
19	_$ = window.$,
20
21	// A central reference to the root jQuery(document)
22	rootjQuery,
23
24	// A simple way to check for HTML strings or ID strings
25	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
26	quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
27
28	// Check if a string has a non-whitespace character in it
29	rnotwhite = /\S/,
30
31	// Used for trimming whitespace
32	trimLeft = /^\s+/,
33	trimRight = /\s+$/,
34
35	// Match a standalone tag
36	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
37
38	// JSON RegExp
39	rvalidchars = /^[\],:{}\s]*$/,
40	rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
41	rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
42	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
43
44	// Useragent RegExp
45	rwebkit = /(webkit)[ \/]([\w.]+)/,
46	ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
47	rmsie = /(msie) ([\w.]+)/,
48	rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
49
50	// Matches dashed string for camelizing
51	rdashAlpha = /-([a-z]|[0-9])/ig,
52	rmsPrefix = /^-ms-/,
53
54	// Used by jQuery.camelCase as callback to replace()
55	fcamelCase = function( all, letter ) {
56		return ( letter + "" ).toUpperCase();
57	},
58
59	// Keep a UserAgent string for use with jQuery.browser
60	userAgent = navigator.userAgent,
61
62	// For matching the engine and version of the browser
63	browserMatch,
64
65	// The deferred used on DOM ready
66	readyList,
67
68	// The ready event handler
69	DOMContentLoaded,
70
71	// Save a reference to some core methods
72	toString = Object.prototype.toString,
73	hasOwn = Object.prototype.hasOwnProperty,
74	push = Array.prototype.push,
75	slice = Array.prototype.slice,
76	trim = String.prototype.trim,
77	indexOf = Array.prototype.indexOf,
78
79	// [[Class]] -> type pairs
80	class2type = {};
81
82jQuery.fn = jQuery.prototype = {
83	constructor: jQuery,
84	init: function( selector, context, rootjQuery ) {
85		var match, elem, ret, doc;
86
87		// Handle $(""), $(null), or $(undefined)
88		if ( !selector ) {
89			return this;
90		}
91
92		// Handle $(DOMElement)
93		if ( selector.nodeType ) {
94			this.context = this[0] = selector;
95			this.length = 1;
96			return this;
97		}
98
99		// The body element only exists once, optimize finding it
100		if ( selector === "body" && !context && document.body ) {
101			this.context = document;
102			this[0] = document.body;
103			this.selector = selector;
104			this.length = 1;
105			return this;
106		}
107
108		// Handle HTML strings
109		if ( typeof selector === "string" ) {
110			// Are we dealing with HTML string or an ID?
111			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
112				// Assume that strings that start and end with <> are HTML and skip the regex check
113				match = [ null, selector, null ];
114
115			} else {
116				match = quickExpr.exec( selector );
117			}
118
119			// Verify a match, and that no context was specified for #id
120			if ( match && (match[1] || !context) ) {
121
122				// HANDLE: $(html) -> $(array)
123				if ( match[1] ) {
124					context = context instanceof jQuery ? context[0] : context;
125					doc = ( context ? context.ownerDocument || context : document );
126
127					// If a single string is passed in and it's a single tag
128					// just do a createElement and skip the rest
129					ret = rsingleTag.exec( selector );
130
131					if ( ret ) {
132						if ( jQuery.isPlainObject( context ) ) {
133							selector = [ document.createElement( ret[1] ) ];
134							jQuery.fn.attr.call( selector, context, true );
135
136						} else {
137							selector = [ doc.createElement( ret[1] ) ];
138						}
139
140					} else {
141						ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
142						selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes;
143					}
144
145					return jQuery.merge( this, selector );
146
147				// HANDLE: $("#id")
148				} else {
149					elem = document.getElementById( match[2] );
150
151					// Check parentNode to catch when Blackberry 4.6 returns
152					// nodes that are no longer in the document #6963
153					if ( elem && elem.parentNode ) {
154						// Handle the case where IE and Opera return items
155						// by name instead of ID
156						if ( elem.id !== match[2] ) {
157							return rootjQuery.find( selector );
158						}
159
160						// Otherwise, we inject the element directly into the jQuery object
161						this.length = 1;
162						this[0] = elem;
163					}
164
165					this.context = document;
166					this.selector = selector;
167					return this;
168				}
169
170			// HANDLE: $(expr, $(...))
171			} else if ( !context || context.jquery ) {
172				return ( context || rootjQuery ).find( selector );
173
174			// HANDLE: $(expr, context)
175			// (which is just equivalent to: $(context).find(expr)
176			} else {
177				return this.constructor( context ).find( selector );
178			}
179
180		// HANDLE: $(function)
181		// Shortcut for document ready
182		} else if ( jQuery.isFunction( selector ) ) {
183			return rootjQuery.ready( selector );
184		}
185
186		if ( selector.selector !== undefined ) {
187			this.selector = selector.selector;
188			this.context = selector.context;
189		}
190
191		return jQuery.makeArray( selector, this );
192	},
193
194	// Start with an empty selector
195	selector: "",
196
197	// The current version of jQuery being used
198	jquery: "1.7.2",
199
200	// The default length of a jQuery object is 0
201	length: 0,
202
203	// The number of elements contained in the matched element set
204	size: function() {
205		return this.length;
206	},
207
208	toArray: function() {
209		return slice.call( this, 0 );
210	},
211
212	// Get the Nth element in the matched element set OR
213	// Get the whole matched element set as a clean array
214	get: function( num ) {
215		return num == null ?
216
217			// Return a 'clean' array
218			this.toArray() :
219
220			// Return just the object
221			( num < 0 ? this[ this.length + num ] : this[ num ] );
222	},
223
224	// Take an array of elements and push it onto the stack
225	// (returning the new matched element set)
226	pushStack: function( elems, name, selector ) {
227		// Build a new jQuery matched element set
228		var ret = this.constructor();
229
230		if ( jQuery.isArray( elems ) ) {
231			push.apply( ret, elems );
232
233		} else {
234			jQuery.merge( ret, elems );
235		}
236
237		// Add the old object onto the stack (as a reference)
238		ret.prevObject = this;
239
240		ret.context = this.context;
241
242		if ( name === "find" ) {
243			ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
244		} else if ( name ) {
245			ret.selector = this.selector + "." + name + "(" + selector + ")";
246		}
247
248		// Return the newly-formed element set
249		return ret;
250	},
251
252	// Execute a callback for every element in the matched set.
253	// (You can seed the arguments with an array of args, but this is
254	// only used internally.)
255	each: function( callback, args ) {
256		return jQuery.each( this, callback, args );
257	},
258
259	ready: function( fn ) {
260		// Attach the listeners
261		jQuery.bindReady();
262
263		// Add the callback
264		readyList.add( fn );
265
266		return this;
267	},
268
269	eq: function( i ) {
270		i = +i;
271		return i === -1 ?
272			this.slice( i ) :
273			this.slice( i, i + 1 );
274	},
275
276	first: function() {
277		return this.eq( 0 );
278	},
279
280	last: function() {
281		return this.eq( -1 );
282	},
283
284	slice: function() {
285		return this.pushStack( slice.apply( this, arguments ),
286			"slice", slice.call(arguments).join(",") );
287	},
288
289	map: function( callback ) {
290		return this.pushStack( jQuery.map(this, function( elem, i ) {
291			return callback.call( elem, i, elem );
292		}));
293	},
294
295	end: function() {
296		return this.prevObject || this.constructor(null);
297	},
298
299	// For internal use only.
300	// Behaves like an Array's method, not like a jQuery method.
301	push: push,
302	sort: [].sort,
303	splice: [].splice
304};
305
306// Give the init function the jQuery prototype for later instantiation
307jQuery.fn.init.prototype = jQuery.fn;
308
309jQuery.extend = jQuery.fn.extend = function() {
310	var options, name, src, copy, copyIsArray, clone,
311		target = arguments[0] || {},
312		i = 1,
313		length = arguments.length,
314		deep = false;
315
316	// Handle a deep copy situation
317	if ( typeof target === "boolean" ) {
318		deep = target;
319		target = arguments[1] || {};
320		// skip the boolean and the target
321		i = 2;
322	}
323
324	// Handle case when target is a string or something (possible in deep copy)
325	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
326		target = {};
327	}
328
329	// extend jQuery itself if only one argument is passed
330	if ( length === i ) {
331		target = this;
332		--i;
333	}
334
335	for ( ; i < length; i++ ) {
336		// Only deal with non-null/undefined values
337		if ( (options = arguments[ i ]) != null ) {
338			// Extend the base object
339			for ( name in options ) {
340				src = target[ name ];
341				copy = options[ name ];
342
343				// Prevent never-ending loop
344				if ( target === copy ) {
345					continue;
346				}
347
348				// Recurse if we're merging plain objects or arrays
349				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
350					if ( copyIsArray ) {
351						copyIsArray = false;
352						clone = src && jQuery.isArray(src) ? src : [];
353
354					} else {
355						clone = src && jQuery.isPlainObject(src) ? src : {};
356					}
357
358					// Never move original objects, clone them
359					target[ name ] = jQuery.extend( deep, clone, copy );
360
361				// Don't bring in undefined values
362				} else if ( copy !== undefined ) {
363					target[ name ] = copy;
364				}
365			}
366		}
367	}
368
369	// Return the modified object
370	return target;
371};
372
373jQuery.extend({
374	noConflict: function( deep ) {
375		if ( window.$ === jQuery ) {
376			window.$ = _$;
377		}
378
379		if ( deep && window.jQuery === jQuery ) {
380			window.jQuery = _jQuery;
381		}
382
383		return jQuery;
384	},
385
386	// Is the DOM ready to be used? Set to true once it occurs.
387	isReady: false,
388
389	// A counter to track how many items to wait for before
390	// the ready event fires. See #6781
391	readyWait: 1,
392
393	// Hold (or release) the ready event
394	holdReady: function( hold ) {
395		if ( hold ) {
396			jQuery.readyWait++;
397		} else {
398			jQuery.ready( true );
399		}
400	},
401
402	// Handle when the DOM is ready
403	ready: function( wait ) {
404		// Either a released hold or an DOMready/load event and not yet ready
405		if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
406			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
407			if ( !document.body ) {
408				return setTimeout( jQuery.ready, 1 );
409			}
410
411			// Remember that the DOM is ready
412			jQuery.isReady = true;
413
414			// If a normal DOM Ready event fired, decrement, and wait if need be
415			if ( wait !== true && --jQuery.readyWait > 0 ) {
416				return;
417			}
418
419			// If there are functions bound, to execute
420			readyList.fireWith( document, [ jQuery ] );
421
422			// Trigger any bound ready events
423			if ( jQuery.fn.trigger ) {
424				jQuery( document ).trigger( "ready" ).off( "ready" );
425			}
426		}
427	},
428
429	bindReady: function() {
430		if ( readyList ) {
431			return;
432		}
433
434		readyList = jQuery.Callbacks( "once memory" );
435
436		// Catch cases where $(document).ready() is called after the
437		// browser event has already occurred.
438		if ( document.readyState === "complete" ) {
439			// Handle it asynchronously to allow scripts the opportunity to delay ready
440			return setTimeout( jQuery.ready, 1 );
441		}
442
443		// Mozilla, Opera and webkit nightlies currently support this event
444		if ( document.addEventListener ) {
445			// Use the handy event callback
446			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
447
448			// A fallback to window.onload, that will always work
449			window.addEventListener( "load", jQuery.ready, false );
450
451		// If IE event model is used
452		} else if ( document.attachEvent ) {
453			// ensure firing before onload,
454			// maybe late but safe also for iframes
455			document.attachEvent( "onreadystatechange", DOMContentLoaded );
456
457			// A fallback to window.onload, that will always work
458			window.attachEvent( "onload", jQuery.ready );
459
460			// If IE and not a frame
461			// continually check to see if the document is ready
462			var toplevel = false;
463
464			try {
465				toplevel = window.frameElement == null;
466			} catch(e) {}
467
468			if ( document.documentElement.doScroll && toplevel ) {
469				doScrollCheck();
470			}
471		}
472	},
473
474	// See test/unit/core.js for details concerning isFunction.
475	// Since version 1.3, DOM methods and functions like alert
476	// aren't supported. They return false on IE (#2968).
477	isFunction: function( obj ) {
478		return jQuery.type(obj) === "function";
479	},
480
481	isArray: Array.isArray || function( obj ) {
482		return jQuery.type(obj) === "array";
483	},
484
485	isWindow: function( obj ) {
486		return obj != null && obj == obj.window;
487	},
488
489	isNumeric: function( obj ) {
490		return !isNaN( parseFloat(obj) ) && isFinite( obj );
491	},
492
493	type: function( obj ) {
494		return obj == null ?
495			String( obj ) :
496			class2type[ toString.call(obj) ] || "object";
497	},
498
499	isPlainObject: function( obj ) {
500		// Must be an Object.
501		// Because of IE, we also have to check the presence of the constructor property.
502		// Make sure that DOM nodes and window objects don't pass through, as well
503		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
504			return false;
505		}
506
507		try {
508			// Not own constructor property must be Object
509			if ( obj.constructor &&
510				!hasOwn.call(obj, "constructor") &&
511				!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
512				return false;
513			}
514		} catch ( e ) {
515			// IE8,9 Will throw exceptions on certain host objects #9897
516			return false;
517		}
518
519		// Own properties are enumerated firstly, so to speed up,
520		// if last one is own, then all properties are own.
521
522		var key;
523		for ( key in obj ) {}
524
525		return key === undefined || hasOwn.call( obj, key );
526	},
527
528	isEmptyObject: function( obj ) {
529		for ( var name in obj ) {
530			return false;
531		}
532		return true;
533	},
534
535	error: function( msg ) {
536		throw new Error( msg );
537	},
538
539	parseJSON: function( data ) {
540		if ( typeof data !== "string" || !data ) {
541			return null;
542		}
543
544		// Make sure leading/trailing whitespace is removed (IE can't handle it)
545		data = jQuery.trim( data );
546
547		// Attempt to parse using the native JSON parser first
548		if ( window.JSON && window.JSON.parse ) {
549			return window.JSON.parse( data );
550		}
551
552		// Make sure the incoming data is actual JSON
553		// Logic borrowed from http://json.org/json2.js
554		if ( rvalidchars.test( data.replace( rvalidescape, "@" )
555			.replace( rvalidtokens, "]" )
556			.replace( rvalidbraces, "")) ) {
557
558			return ( new Function( "return " + data ) )();
559
560		}
561		jQuery.error( "Invalid JSON: " + data );
562	},
563
564	// Cross-browser xml parsing
565	parseXML: function( data ) {
566		if ( typeof data !== "string" || !data ) {
567			return null;
568		}
569		var xml, tmp;
570		try {
571			if ( window.DOMParser ) { // Standard
572				tmp = new DOMParser();
573				xml = tmp.parseFromString( data , "text/xml" );
574			} else { // IE
575				xml = new ActiveXObject( "Microsoft.XMLDOM" );
576				xml.async = "false";
577				xml.loadXML( data );
578			}
579		} catch( e ) {
580			xml = undefined;
581		}
582		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
583			jQuery.error( "Invalid XML: " + data );
584		}
585		return xml;
586	},
587
588	noop: function() {},
589
590	// Evaluates a script in a global context
591	// Workarounds based on findings by Jim Driscoll
592	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
593	globalEval: function( data ) {
594		if ( data && rnotwhite.test( data ) ) {
595			// We use execScript on Internet Explorer
596			// We use an anonymous function so that context is window
597			// rather than jQuery in Firefox
598			( window.execScript || function( data ) {
599				window[ "eval" ].call( window, data );
600			} )( data );
601		}
602	},
603
604	// Convert dashed to camelCase; used by the css and data modules
605	// Microsoft forgot to hump their vendor prefix (#9572)
606	camelCase: function( string ) {
607		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
608	},
609
610	nodeName: function( elem, name ) {
611		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
612	},
613
614	// args is for internal usage only
615	each: function( object, callback, args ) {
616		var name, i = 0,
617			length = object.length,
618			isObj = length === undefined || jQuery.isFunction( object );
619
620		if ( args ) {
621			if ( isObj ) {
622				for ( name in object ) {
623					if ( callback.apply( object[ name ], args ) === false ) {
624						break;
625					}
626				}
627			} else {
628				for ( ; i < length; ) {
629					if ( callback.apply( object[ i++ ], args ) === false ) {
630						break;
631					}
632				}
633			}
634
635		// A special, fast, case for the most common use of each
636		} else {
637			if ( isObj ) {
638				for ( name in object ) {
639					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
640						break;
641					}
642				}
643			} else {
644				for ( ; i < length; ) {
645					if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
646						break;
647					}
648				}
649			}
650		}
651
652		return object;
653	},
654
655	// Use native String.trim function wherever possible
656	trim: trim ?
657		function( text ) {
658			return text == null ?
659				"" :
660				trim.call( text );
661		} :
662
663		// Otherwise use our own trimming functionality
664		function( text ) {
665			return text == null ?
666				"" :
667				text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
668		},
669
670	// results is for internal usage only
671	makeArray: function( array, results ) {
672		var ret = results || [];
673
674		if ( array != null ) {
675			// The window, strings (and functions) also have 'length'
676			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
677			var type = jQuery.type( array );
678
679			if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
680				push.call( ret, array );
681			} else {
682				jQuery.merge( ret, array );
683			}
684		}
685
686		return ret;
687	},
688
689	inArray: function( elem, array, i ) {
690		var len;
691
692		if ( array ) {
693			if ( indexOf ) {
694				return indexOf.call( array, elem, i );
695			}
696
697			len = array.length;
698			i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
699
700			for ( ; i < len; i++ ) {
701				// Skip accessing in sparse arrays
702				if ( i in array && array[ i ] === elem ) {
703					return i;
704				}
705			}
706		}
707
708		return -1;
709	},
710
711	merge: function( first, second ) {
712		var i = first.length,
713			j = 0;
714
715		if ( typeof second.length === "number" ) {
716			for ( var l = second.length; j < l; j++ ) {
717				first[ i++ ] = second[ j ];
718			}
719
720		} else {
721			while ( second[j] !== undefined ) {
722				first[ i++ ] = second[ j++ ];
723			}
724		}
725
726		first.length = i;
727
728		return first;
729	},
730
731	grep: function( elems, callback, inv ) {
732		var ret = [], retVal;
733		inv = !!inv;
734
735		// Go through the array, only saving the items
736		// that pass the validator function
737		for ( var i = 0, length = elems.length; i < length; i++ ) {
738			retVal = !!callback( elems[ i ], i );
739			if ( inv !== retVal ) {
740				ret.push( elems[ i ] );
741			}
742		}
743
744		return ret;
745	},
746
747	// arg is for internal usage only
748	map: function( elems, callback, arg ) {
749		var value, key, ret = [],
750			i = 0,
751			length = elems.length,
752			// jquery objects are treated as arrays
753			isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
754
755		// Go through the array, translating each of the items to their
756		if ( isArray ) {
757			for ( ; i < length; i++ ) {
758				value = callback( elems[ i ], i, arg );
759
760				if ( value != null ) {
761					ret[ ret.length ] = value;
762				}
763			}
764
765		// Go through every key on the object,
766		} else {
767			for ( key in elems ) {
768				value = callback( elems[ key ], key, arg );
769
770				if ( value != null ) {
771					ret[ ret.length ] = value;
772				}
773			}
774		}
775
776		// Flatten any nested arrays
777		return ret.concat.apply( [], ret );
778	},
779
780	// A global GUID counter for objects
781	guid: 1,
782
783	// Bind a function to a context, optionally partially applying any
784	// arguments.
785	proxy: function( fn, context ) {
786		if ( typeof context === "string" ) {
787			var tmp = fn[ context ];
788			context = fn;
789			fn = tmp;
790		}
791
792		// Quick check to determine if target is callable, in the spec
793		// this throws a TypeError, but we will just return undefined.
794		if ( !jQuery.isFunction( fn ) ) {
795			return undefined;
796		}
797
798		// Simulated bind
799		var args = slice.call( arguments, 2 ),
800			proxy = function() {
801				return fn.apply( context, args.concat( slice.call( arguments ) ) );
802			};
803
804		// Set the guid of unique handler to the same of original handler, so it can be removed
805		proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
806
807		return proxy;
808	},
809
810	// Mutifunctional method to get and set values to a collection
811	// The value/s can optionally be executed if it's a function
812	access: function( elems, fn, key, value, chainable, emptyGet, pass ) {
813		var exec,
814			bulk = key == null,
815			i = 0,
816			length = elems.length;
817
818		// Sets many values
819		if ( key && typeof key === "object" ) {
820			for ( i in key ) {
821				jQuery.access( elems, fn, i, key[i], 1, emptyGet, value );
822			}
823			chainable = 1;
824
825		// Sets one value
826		} else if ( value !== undefined ) {
827			// Optionally, function values get executed if exec is true
828			exec = pass === undefined && jQuery.isFunction( value );
829
830			if ( bulk ) {
831				// Bulk operations only iterate when executing function values
832				if ( exec ) {
833					exec = fn;
834					fn = function( elem, key, value ) {
835						return exec.call( jQuery( elem ), value );
836					};
837
838				// Otherwise they run against the entire set
839				} else {
840					fn.call( elems, value );
841					fn = null;
842				}
843			}
844
845			if ( fn ) {
846				for (; i < length; i++ ) {
847					fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
848				}
849			}
850
851			chainable = 1;
852		}
853
854		return chainable ?
855			elems :
856
857			// Gets
858			bulk ?
859				fn.call( elems ) :
860				length ? fn( elems[0], key ) : emptyGet;
861	},
862
863	now: function() {
864		return ( new Date() ).getTime();
865	},
866
867	// Use of jQuery.browser is frowned upon.
868	// More details: http://docs.jquery.com/Utilities/jQuery.browser
869	uaMatch: function( ua ) {
870		ua = ua.toLowerCase();
871
872		var match = rwebkit.exec( ua ) ||
873			ropera.exec( ua ) ||
874			rmsie.exec( ua ) ||
875			ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
876			[];
877
878		return { browser: match[1] || "", version: match[2] || "0" };
879	},
880
881	sub: function() {
882		function jQuerySub( selector, context ) {
883			return new jQuerySub.fn.init( selector, context );
884		}
885		jQuery.extend( true, jQuerySub, this );
886		jQuerySub.superclass = this;
887		jQuerySub.fn = jQuerySub.prototype = this();
888		jQuerySub.fn.constructor = jQuerySub;
889		jQuerySub.sub = this.sub;
890		jQuerySub.fn.init = function init( selector, context ) {
891			if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
892				context = jQuerySub( context );
893			}
894
895			return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
896		};
897		jQuerySub.fn.init.prototype = jQuerySub.fn;
898		var rootjQuerySub = jQuerySub(document);
899		return jQuerySub;
900	},
901
902	browser: {}
903});
904
905// Populate the class2type map
906jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
907	class2type[ "[object " + name + "]" ] = name.toLowerCase();
908});
909
910browserMatch = jQuery.uaMatch( userAgent );
911if ( browserMatch.browser ) {
912	jQuery.browser[ browserMatch.browser ] = true;
913	jQuery.browser.version = browserMatch.version;
914}
915
916// Deprecated, use jQuery.browser.webkit instead
917if ( jQuery.browser.webkit ) {
918	jQuery.browser.safari = true;
919}
920

1726		// An object can be passed to jQuery.data instead of a key/value pair; this gets
1727		// shallow copied over onto the existing cache
1728		if ( typeof name === "object" || typeof name === "function" ) {
1729			if ( pvt ) {
1730				cache[ id ] = jQuery.extend( cache[ id ], name );
1731			} else {
1732				cache[ id ].data = jQuery.extend( cache[ id ].data, name );
1733			}
1734		}
1735
1736		privateCache = thisCache = cache[ id ];
1737
1738		// jQuery data() is stored in a separate object inside the object's internal data
1739		// cache in order to avoid key collisions between internal data and user-defined
1740		// data.
1741		if ( !pvt ) {
1742			if ( !thisCache.data ) {
1743				thisCache.data = {};
1744			}
1745
1746			thisCache = thisCache.data;
1747		}
1748
1749		if ( data !== undefined ) {
1750			thisCache[ jQuery.camelCase( name ) ] = data;
1751		}
1752
1753		// Users should not attempt to inspect the internal events object using jQuery.data,
1754		// it is undocumented and subject to change. But does anyone listen? No.
1755		if ( isEvents && !thisCache[ name ] ) {
1756			return privateCache.events;
1757		}
1758
1759		// Check for both converted-to-camel and non-converted data property names
1760		// If a data property was specified
1761		if ( getByName ) {
1762
1763			// First Try to find as-is property data
1764			ret = thisCache[ name ];
1765
1766			// Test for null|undefined property data
1767			if ( ret == null ) {
1768
1769				// Try to find the camelCased property
1770				ret = thisCache[ jQuery.camelCase( name ) ];
1771			}
1772		} else {
1773			ret = thisCache;
1774		}
1775
1776		return ret;
1777	},
1778
1779	removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1780		if ( !jQuery.acceptData( elem ) ) {
1781			return;
1782		}
1783
1784		var thisCache, i, l,
1785
1786			// Reference to internal data cache key
1787			internalKey = jQuery.expando,
1788
1789			isNode = elem.nodeType,
1790
1791			// See jQuery.data for more information
1792			cache = isNode ? jQuery.cache : elem,
1793
1794			// See jQuery.data for more information
1795			id = isNode ? elem[ internalKey ] : internalKey;
1796
1797		// If there is already no cache entry for this object, there is no
1798		// purpose in continuing
1799		if ( !cache[ id ] ) {
1800			return;
1801		}
1802
1803		if ( name ) {
1804
1805			thisCache = pvt ? cache[ id ] : cache[ id ].data;
1806
1807			if ( thisCache ) {
1808
1809				// Support array or space separated string names for data keys
1810				if ( !jQuery.isArray( name ) ) {
1811
1812					// try the string as a key before any manipulation
1813					if ( name in thisCache ) {
1814						name = [ name ];
1815					} else {
1816
1817						// split the camel cased version by spaces unless a key with the spaces exists
1818						name = jQuery.camelCase( name );
1819						if ( name in thisCache ) {
1820							name = [ name ];
1821						} else {
1822							name = name.split( " " );
1823						}
1824					}
1825				}
1826
1827				for ( i = 0, l = name.length; i < l; i++ ) {
1828					delete thisCache[ name[i] ];
1829				}
1830
1831				// If there is no data left in the cache, we want to continue
1832				// and let the cache object itself get destroyed
1833				if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
1834					return;
1835				}
1836			}
1837		}
1838
1839		// See jQuery.data for more information
1840		if ( !pvt ) {
1841			delete cache[ id ].data;
1842
1843			// Don't destroy the parent cache unless the internal data object
1844			// had been the only thing left in it
1845			if ( !isEmptyDataObject(cache[ id ]) ) {
1846				return;
1847			}
1848		}
1849
1850		// Browsers that fail expando deletion also refuse to delete expandos on
1851		// the window, but it will allow it on all other JS objects; other browsers
1852		// don't care
1853		// Ensure that `cache` is not a window object #10080
1854		if ( jQuery.support.deleteExpando || !cache.setInterval ) {
1855			delete cache[ id ];
1856		} else {
1857			cache[ id ] = null;
1858		}
1859
1860		// We destroyed the cache and need to eliminate the expando on the node to avoid
1861		// false lookups in the cache for entries that no longer exist
1862		if ( isNode ) {
1863			// IE does not allow us to delete expando properties from nodes,
1864			// nor does it have a removeAttribute function on Document nodes;
1865			// we must handle all of these cases
1866			if ( jQuery.support.deleteExpando ) {
1867				delete elem[ internalKey ];
1868			} else if ( elem.removeAttribute ) {
1869				elem.removeAttribute( internalKey );
1870			} else {
1871				elem[ internalKey ] = null;
1872			}
1873		}
1874	},
1875
1876	// For internal use only.
1877	_data: function( elem, name, data ) {
1878		return jQuery.data( elem, name, data, true );
1879	},
1880
1881	// A method for determining if a DOM node can handle the data expando
1882	acceptData: function( elem ) {
1883		if ( elem.nodeName ) {
1884			var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1885
1886			if ( match ) {
1887				return !(match === true || elem.getAttribute("classid") !== match);
1888			}
1889		}
1890
1891		return true;
1892	}
1893});
1894
1895jQuery.fn.extend({
1896	data: function( key, value ) {
1897		var parts, part, attr, name, l,
1898			elem = this[0],
1899			i = 0,
1900			data = null;
1901
1902		// Gets all values
1903		if ( key === undefined ) {
1904			if ( this.length ) {
1905				data = jQuery.data( elem );
1906
1907				if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
1908					attr = elem.attributes;
1909					for ( l = attr.length; i < l; i++ ) {
1910						name = attr[i].name;
1911

2086		type = type || "fx";
2087
2088		var queue = jQuery.queue( elem, type ),
2089			fn = queue.shift(),
2090			hooks = {};
2091
2092		// If the fx queue is dequeued, always remove the progress sentinel
2093		if ( fn === "inprogress" ) {
2094			fn = queue.shift();
2095		}
2096
2097		if ( fn ) {
2098			// Add a progress sentinel to prevent the fx queue from being
2099			// automatically dequeued
2100			if ( type === "fx" ) {
2101				queue.unshift( "inprogress" );
2102			}
2103
2104			jQuery._data( elem, type + ".run", hooks );
2105			fn.call( elem, function() {
2106				jQuery.dequeue( elem, type );
2107			}, hooks );
2108		}
2109
2110		if ( !queue.length ) {
2111			jQuery.removeData( elem, type + "queue " + type + ".run", true );
2112			handleQueueMarkDefer( elem, type, "queue" );
2113		}
2114	}
2115});
2116
2117jQuery.fn.extend({
2118	queue: function( type, data ) {
2119		var setter = 2;
2120
2121		if ( typeof type !== "string" ) {
2122			data = type;
2123			type = "fx";
2124			setter--;
2125		}
2126
2127		if ( arguments.length < setter ) {
2128			return jQuery.queue( this[0], type );
2129		}
2130
2131		return data === undefined ?
2132			this :
2133			this.each(function() {
2134				var queue = jQuery.queue( this, type, data );
2135
2136				if ( type === "fx" && queue[0] !== "inprogress" ) {
2137					jQuery.dequeue( this, type );
2138				}
2139			});
2140	},
2141	dequeue: function( type ) {
2142		return this.each(function() {
2143			jQuery.dequeue( this, type );
2144		});
2145	},
2146	// Based off of the plugin by Clint Helfers, with permission.
2147	// http://blindsignals.com/index.php/2009/07/jquery-delay/
2148	delay: function( time, type ) {
2149		time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
2150		type = type || "fx";
2151
2152		return this.queue( type, function( next, hooks ) {
2153			var timeout = setTimeout( next, time );
2154			hooks.stop = function() {
2155				clearTimeout( timeout );
2156			};
2157		});
2158	},
2159	clearQueue: function( type ) {
2160		return this.queue( type || "fx", [] );
2161	},
2162	// Get a promise resolved when queues of a certain type
2163	// are emptied (fx is the type by default)
2164	promise: function( type, object ) {
2165		if ( typeof type !== "string" ) {
2166			object = type;
2167			type = undefined;
2168		}
2169		type = type || "fx";
2170		var defer = jQuery.Deferred(),
2171			elements = this,
2172			i = elements.length,
2173			count = 1,
2174			deferDataKey = type + "defer",
2175			queueDataKey = type + "queue",
2176			markDataKey = type + "mark",
2177			tmp;
2178		function resolve() {
2179			if ( !( --count ) ) {
2180				defer.resolveWith( elements, [ elements ] );
2181			}
2182		}
2183		while( i-- ) {
2184			if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
2185					( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
2186						jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
2187					jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) {
2188				count++;
2189				tmp.add( resolve );
2190			}
2191		}
2192		resolve();
2193		return defer.promise( object );
2194	}
2195});
2196
2197
2198
2199
2200var rclass = /[\n\t\r]/g,
2201	rspace = /\s+/,
2202	rreturn = /\r/g,
2203	rtype = /^(?:button|input)$/i,
2204	rfocusable = /^(?:button|input|object|select|textarea)$/i,
2205	rclickable = /^a(?:rea)?$/i,
2206	rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
2207	getSetAttribute = jQuery.support.getSetAttribute,
2208	nodeHook, boolHook, fixSpecified;
2209
2210jQuery.fn.extend({
2211	attr: function( name, value ) {
2212		return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
2213	},
2214
2215	removeAttr: function( name ) {
2216		return this.each(function() {
2217			jQuery.removeAttr( this, name );
2218		});
2219	},
2220
2221	prop: function( name, value ) {
2222		return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
2223	},
2224
2225	removeProp: function( name ) {
2226		name = jQuery.propFix[ name ] || name;
2227		return this.each(function() {
2228			// try/catch handles cases where IE balks (such as removing a property on window)
2229			try {
2230				this[ name ] = undefined;
2231				delete this[ name ];
2232			} catch( e ) {}
2233		});
2234	},
2235
2236	addClass: function( value ) {
2237		var classNames, i, l, elem,
2238			setClass, c, cl;
2239
2240		if ( jQuery.isFunction( value ) ) {
2241			return this.each(function( j ) {
2242				jQuery( this ).addClass( value.call(this, j, this.className) );
2243			});
2244		}
2245
2246		if ( value && typeof value === "string" ) {
2247			classNames = value.split( rspace );
2248
2249			for ( i = 0, l = this.length; i < l; i++ ) {
2250				elem = this[ i ];
2251
2252				if ( elem.nodeType === 1 ) {
2253					if ( !elem.className && classNames.length === 1 ) {
2254						elem.className = value;
2255
2256					} else {
2257						setClass = " " + elem.className + " ";
2258
2259						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2260							if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
2261								setClass += classNames[ c ] + " ";
2262							}
2263						}
2264						elem.className = jQuery.trim( setClass );
2265					}
2266				}
2267			}
2268		}
2269
2270		return this;
2271	},
2272
2273	removeClass: function( value ) {
2274		var classNames, i, l, elem, className, c, cl;
2275
2276		if ( jQuery.isFunction( value ) ) {
2277			return this.each(function( j ) {
2278				jQuery( this ).removeClass( value.call(this, j, this.className) );
2279			});
2280		}
2281
2282		if ( (value && typeof value === "string") || value === undefined ) {
2283			classNames = ( value || "" ).split( rspace );
2284
2285			for ( i = 0, l = this.length; i < l; i++ ) {
2286				elem = this[ i ];
2287
2288				if ( elem.nodeType === 1 && elem.className ) {
2289					if ( value ) {
2290						className = (" " + elem.className + " ").replace( rclass, " " );
2291						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2292							className = className.replace(" " + classNames[ c ] + " ", " ");
2293						}
2294						elem.className = jQuery.trim( className );
2295
2296					} else {
2297						elem.className = "";
2298					}
2299				}
2300			}
2301		}
2302
2303		return this;
2304	},
2305
2306	toggleClass: function( value, stateVal ) {
2307		var type = typeof value,
2308			isBool = typeof stateVal === "boolean";
2309
2310		if ( jQuery.isFunction( value ) ) {
2311			return this.each(function( i ) {
2312				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
2313			});
2314		}
2315
2316		return this.each(function() {
2317			if ( type === "string" ) {
2318				// toggle individual class names
2319				var className,
2320					i = 0,
2321					self = jQuery( this ),
2322					state = stateVal,
2323					classNames = value.split( rspace );
2324
2325				while ( (className = classNames[ i++ ]) ) {
2326					// check each className given, space seperated list
2327					state = isBool ? state : !self.hasClass( className );
2328					self[ state ? "addClass" : "removeClass" ]( className );
2329				}
2330
2331			} else if ( type === "undefined" || type === "boolean" ) {
2332				if ( this.className ) {
2333					// store className if set
2334					jQuery._data( this, "__className__", this.className );
2335				}
2336
2337				// toggle whole className
2338				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2339			}
2340		});
2341	},
2342
2343	hasClass: function( selector ) {
2344		var className = " " + selector + " ",
2345			i = 0,
2346			l = this.length;
2347		for ( ; i < l; i++ ) {
2348			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2349				return true;
2350			}
2351		}
2352
2353		return false;
2354	},
2355
2356	val: function( value ) {
2357		var hooks, ret, isFunction,
2358			elem = this[0];
2359
2360		if ( !arguments.length ) {
2361			if ( elem ) {
2362				hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
2363
2364				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2365					return ret;
2366				}
2367
2368				ret = elem.value;
2369
2370				return typeof ret === "string" ?
2371					// handle most common string cases
2372					ret.replace(rreturn, "") :
2373					// handle cases where value is null/undef or number
2374					ret == null ? "" : ret;
2375			}
2376
2377			return;
2378		}
2379
2380		isFunction = jQuery.isFunction( value );
2381
2382		return this.each(function( i ) {
2383			var self = jQuery(this), val;
2384
2385			if ( this.nodeType !== 1 ) {
2386				return;
2387			}
2388
2389			if ( isFunction ) {
2390				val = value.call( this, i, self.val() );
2391			} else {
2392				val = value;
2393			}
2394
2395			// Treat null/undefined as ""; convert numbers to string
2396			if ( val == null ) {
2397				val = "";
2398			} else if ( typeof val === "number" ) {
2399				val += "";
2400			} else if ( jQuery.isArray( val ) ) {
2401				val = jQuery.map(val, function ( value ) {
2402					return value == null ? "" : value + "";
2403				});
2404			}
2405
2406			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
2407
2408			// If set returns undefined, fall back to normal setting
2409			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
2410				this.value = val;
2411			}
2412		});
2413	}
2414});
2415
2416jQuery.extend({
2417	valHooks: {
2418		option: {
2419			get: function( elem ) {
2420				// attributes.value is undefined in Blackberry 4.7 but
2421				// uses .value. See #6932
2422				var val = elem.attributes.value;
2423				return !val || val.specified ? elem.value : elem.text;
2424			}
2425		},
2426		select: {
2427			get: function( elem ) {
2428				var value, i, max, option,
2429					index = elem.selectedIndex,
2430					values = [],
2431					options = elem.options,
2432					one = elem.type === "select-one";
2433
2434				// Nothing was selected
2435				if ( index < 0 ) {
2436					return null;
2437				}
2438
2439				// Loop through all the selected options
2440				i = one ? index : 0;
2441				max = one ? index + 1 : options.length;
2442				for ( ; i < max; i++ ) {
2443					option = options[ i ];
2444
2445					// Don't return options that are disabled or in a disabled optgroup
2446					if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2447							(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
2448
2449						// Get the specific value for the option
2450						value = jQuery( option ).val();
2451
2452						// We don't need an array for one selects
2453						if ( one ) {
2454							return value;
2455						}
2456
2457						// Multi-Selects return an array
2458						values.push( value );
2459					}
2460				}
2461
2462				// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2463				if ( one && !values.length && options.length ) {
2464					return jQuery( options[ index ] ).val();
2465				}
2466
2467				return values;
2468			},
2469
2470			set: function( elem, value ) {
2471				var values = jQuery.makeArray( value );
2472
2473				jQuery(elem).find("option").each(function() {
2474					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2475				});
2476
2477				if ( !values.length ) {
2478					elem.selectedIndex = -1;
2479				}
2480				return values;
2481			}
2482		}
2483	},
2484
2485	attrFn: {
2486		val: true,
2487		css: true,
2488		html: true,
2489		text: true,
2490		data: true,
2491		width: true,
2492		height: true,
2493		offset: true
2494	},
2495
2496	attr: function( elem, name, value, pass ) {
2497		var ret, hooks, notxml,
2498			nType = elem.nodeType;
2499
2500		// don't get/set attributes on text, comment and attribute nodes
2501		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2502			return;
2503		}
2504
2505		if ( pass && name in jQuery.attrFn ) {
2506			return jQuery( elem )[ name ]( value );
2507		}
2508
2509		// Fallback to prop when attributes are not supported
2510		if ( typeof elem.getAttribute === "undefined" ) {
2511			return jQuery.prop( elem, name, value );
2512		}
2513
2514		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2515
2516		// All attributes are lowercase
2517		// Grab necessary hook if one is defined
2518		if ( notxml ) {
2519			name = name.toLowerCase();
2520			hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
2521		}
2522
2523		if ( value !== undefined ) {
2524
2525			if ( value === null ) {
2526				jQuery.removeAttr( elem, name );
2527				return;
2528
2529			} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2530				return ret;
2531
2532			} else {
2533				elem.setAttribute( name, "" + value );
2534				return value;
2535			}
2536
2537		} else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
2538			return ret;
2539
2540		} else {
2541
2542			ret = elem.getAttribute( name );
2543
2544			// Non-existent attributes return null, we normalize to undefined
2545			return ret === null ?
2546				undefined :
2547				ret;
2548		}
2549	},
2550
2551	removeAttr: function( elem, value ) {
2552		var propName, attrNames, name, l, isBool,
2553			i = 0;
2554
2555		if ( value && elem.nodeType === 1 ) {
2556			attrNames = value.toLowerCase().split( rspace );
2557			l = attrNames.length;
2558
2559			for ( ; i < l; i++ ) {
2560				name = attrNames[ i ];
2561
2562				if ( name ) {
2563					propName = jQuery.propFix[ name ] || name;
2564					isBool = rboolean.test( name );
2565
2566					// See #9699 for explanation of this approach (setting first, then removal)
2567					// Do not do this for boolean attributes (see #10870)
2568					if ( !isBool ) {
2569						jQuery.attr( elem, name, "" );
2570					}
2571					elem.removeAttribute( getSetAttribute ? name : propName );
2572
2573					// Set corresponding property to false for boolean attributes
2574					if ( isBool && propName in elem ) {
2575						elem[ propName ] = false;
2576					}
2577				}
2578			}
2579		}
2580	},
2581
2582	attrHooks: {
2583		type: {
2584			set: function( elem, value ) {
2585				// We can't allow the type property to be changed (since it causes problems in IE)
2586				if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
2587					jQuery.error( "type property can't be changed" );
2588				} else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2589					// Setting the type on a radio button after the value resets the value in IE6-9
2590					// Reset value to it's default in case type is set after value
2591					// This is for element creation
2592					var val = elem.value;
2593					elem.setAttribute( "type", value );
2594					if ( val ) {
2595						elem.value = val;
2596					}
2597					return value;
2598				}
2599			}
2600		},
2601		// Use the value property for back compat
2602		// Use the nodeHook for button elements in IE6/7 (#1954)
2603		value: {
2604			get: function( elem, name ) {
2605				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2606					return nodeHook.get( elem, name );
2607				}
2608				return name in elem ?
2609					elem.value :
2610					null;
2611			},
2612			set: function( elem, value, name ) {
2613				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2614					return nodeHook.set( elem, value, name );
2615				}
2616				// Does not return so that setAttribute is also used
2617				elem.value = value;
2618			}
2619		}
2620	},
2621
2622	propFix: {
2623		tabindex: "tabIndex",
2624		readonly: "readOnly",
2625		"for": "htmlFor",
2626		"class": "className",
2627		maxlength: "maxLength",
2628		cellspacing: "cellSpacing",
2629		cellpadding: "cellPadding",
2630		rowspan: "rowSpan",
2631		colspan: "colSpan",
2632		usemap: "useMap",
2633		frameborder: "frameBorder",
2634		contenteditable: "contentEditable"
2635	},
2636
2637	prop: function( elem, name, value ) {
2638		var ret, hooks, notxml,
2639			nType = elem.nodeType;
2640
2641		// don't get/set properties on text, comment and attribute nodes
2642		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2643			return;
2644		}
2645
2646		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2647
2648		if ( notxml ) {
2649			// Fix name and attach hooks
2650			name = jQuery.propFix[ name ] || name;
2651			hooks = jQuery.propHooks[ name ];
2652		}
2653
2654		if ( value !== undefined ) {
2655			if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2656				return ret;
2657
2658			} else {
2659				return ( elem[ name ] = value );
2660			}
2661
2662		} else {
2663			if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
2664				return ret;
2665
2666			} else {
2667				return elem[ name ];
2668			}
2669		}
2670	},
2671
2672	propHooks: {
2673		tabIndex: {
2674			get: function( elem ) {
2675				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2676				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2677				var attributeNode = elem.getAttributeNode("tabindex");
2678
2679				return attributeNode && attributeNode.specified ?
2680					parseInt( attributeNode.value, 10 ) :
2681					rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
2682						0 :
2683						undefined;
2684			}
2685		}
2686	}
2687});
2688
2689// Add the tabIndex propHook to attrHooks for back-compat (different case is intentional)
2690jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex;
2691
2692// Hook for boolean attributes
2693boolHook = {
2694	get: function( elem, name ) {
2695		// Align boolean attributes with corresponding properties
2696		// Fall back to attribute presence where some booleans are not supported
2697		var attrNode,
2698			property = jQuery.prop( elem, name );
2699		return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
2700			name.toLowerCase() :
2701			undefined;
2702	},
2703	set: function( elem, value, name ) {
2704		var propName;
2705		if ( value === false ) {
2706			// Remove boolean attributes when set to false
2707			jQuery.removeAttr( elem, name );
2708		} else {
2709			// value is true since we know at this point it's type boolean and not false
2710			// Set boolean attributes to the same name and set the DOM property
2711			propName = jQuery.propFix[ name ] || name;
2712			if ( propName in elem ) {
2713				// Only set the IDL specifically if it already exists on the element
2714				elem[ propName ] = true;
2715			}
2716
2717			elem.setAttribute( name, name.toLowerCase() );
2718		}
2719		return name;
2720	}
2721};
2722
2723// IE6/7 do not support getting/setting some attributes with get/setAttribute
2724if ( !getSetAttribute ) {
2725
2726	fixSpecified = {
2727		name: true,
2728		id: true,
2729		coords: true
2730	};
2731
2732	// Use this for any attribute in IE6/7
2733	// This fixes almost every IE6/7 issue
2734	nodeHook = jQuery.valHooks.button = {
2735		get: function( elem, name ) {
2736			var ret;
2737			ret = elem.getAttributeNode( name );
2738			return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ?
2739				ret.nodeValue :
2740				undefined;
2741		},
2742		set: function( elem, value, name ) {
2743			// Set the existing or create a new attribute node
2744			var ret = elem.getAttributeNode( name );
2745			if ( !ret ) {
2746				ret = document.createAttribute( name );
2747				elem.setAttributeNode( ret );
2748			}
2749			return ( ret.nodeValue = value + "" );
2750		}
2751	};
2752
2753	// Apply the nodeHook to tabindex
2754	jQuery.attrHooks.tabindex.set = nodeHook.set;
2755
2756	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
2757	// This is for removals
2758	jQuery.each([ "width", "height" ], function( i, name ) {
2759		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2760			set: function( elem, value ) {
2761				if ( value === "" ) {
2762					elem.setAttribute( name, "auto" );
2763					return value;
2764				}
2765			}
2766		});
2767	});
2768
2769	// Set contenteditable to false on removals(#10429)
2770	// Setting to empty string throws an error as an invalid value
2771	jQuery.attrHooks.contenteditable = {
2772		get: nodeHook.get,
2773		set: function( elem, value, name ) {
2774			if ( value === "" ) {
2775				value = "false";
2776			}
2777			nodeHook.set( elem, value, name );
2778		}
2779	};
2780}
2781
2782
2783// Some attributes require a special call on IE
2784if ( !jQuery.support.hrefNormalized ) {
2785	jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
2786		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2787			get: function( elem ) {
2788				var ret = elem.getAttribute( name, 2 );
2789				return ret === null ? undefined : ret;
2790			}
2791		});
2792	});
2793}
2794
2795if ( !jQuery.support.style ) {
2796	jQuery.attrHooks.style = {
2797		get: function( elem ) {
2798			// Return undefined in the case of empty string
2799			// Normalize to lowercase since IE uppercases css property names
2800			return elem.style.cssText.toLowerCase() || undefined;
2801		},
2802		set: function( elem, value ) {
2803			return ( elem.style.cssText = "" + value );
2804		}
2805	};
2806}
2807
2808// Safari mis-reports the default selected property of an option
2809// Accessing the parent's selectedIndex property fixes it
2810if ( !jQuery.support.optSelected ) {
2811	jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
2812		get: function( elem ) {
2813			var parent = elem.parentNode;
2814
2815			if ( parent ) {
2816				parent.selectedIndex;
2817
2818				// Make sure that it also works with optgroups, see #5701
2819				if ( parent.parentNode ) {
2820					parent.parentNode.selectedIndex;
2821				}
2822			}
2823			return null;
2824		}
2825	});
2826}
2827
2828// IE6/7 call enctype encoding
2829if ( !jQuery.support.enctype ) {
2830	jQuery.propFix.enctype = "encoding";
2831}
2832
2833// Radios and checkboxes getter/setter
2834if ( !jQuery.support.checkOn ) {
2835	jQuery.each([ "radio", "checkbox" ], function() {
2836		jQuery.valHooks[ this ] = {
2837			get: function( elem ) {
2838				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2839				return elem.getAttribute("value") === null ? "on" : elem.value;
2840			}
2841		};
2842	});
2843}
2844jQuery.each([ "radio", "checkbox" ], function() {
2845	jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2846		set: function( elem, value ) {
2847			if ( jQuery.isArray( value ) ) {
2848				return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
2849			}
2850		}
2851	});
2852});
2853
2854
2855
2856
2857var rformElems = /^(?:textarea|input|select)$/i,
2858	rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/,
2859	rhoverHack = /(?:^|\s)hover(\.\S+)?\b/,
2860	rkeyEvent = /^key/,
2861	rmouseEvent = /^(?:mouse|contextmenu)|click/,
2862	rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
2863	rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,
2864	quickParse = function( selector ) {
2865		var quick = rquickIs.exec( selector );
2866		if ( quick ) {
2867			//   0  1    2   3
2868			// [ _, tag, id, class ]
2869			quick[1] = ( quick[1] || "" ).toLowerCase();
2870			quick[3] = quick[3] && new RegExp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" );
2871		}
2872		return quick;
2873	},
2874	quickIs = function( elem, m ) {
2875		var attrs = elem.attributes || {};
2876		return (
2877			(!m[1] || elem.nodeName.toLowerCase() === m[1]) &&
2878			(!m[2] || (attrs.id || {}).value === m[2]) &&
2879			(!m[3] || m[3].test( (attrs[ "class" ] || {}).value ))
2880		);
2881	},
2882	hoverHack = function( events ) {
2883		return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
2884	};
2885
2886/*
2887 * Helper functions for managing events -- not part of the public interface.
2888 * Props to Dean Edwards' addEvent library for many of the ideas.
2889 */
2890jQuery.event = {
2891
2892	add: function( elem, types, handler, data, selector ) {
2893
2894		var elemData, eventHandle, events,
2895			t, tns, type, namespaces, handleObj,
2896			handleObjIn, quick, handlers, special;
2897
2898		// Don't attach events to noData or text/comment nodes (allow plain objects tho)
2899		if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
2900			return;
2901		}
2902
2903		// Caller can pass in an object of custom data in lieu of the handler
2904		if ( handler.handler ) {
2905			handleObjIn = handler;
2906			handler = handleObjIn.handler;
2907			selector = handleObjIn.selector;
2908		}
2909
2910		// Make sure that the handler has a unique ID, used to find/remove it later
2911		if ( !handler.guid ) {
2912			handler.guid = jQuery.guid++;
2913		}
2914
2915		// Init the element's event structure and main handler, if this is the first
2916		events = elemData.events;
2917		if ( !events ) {
2918			elemData.events = events = {};
2919		}
2920		eventHandle = elemData.handle;
2921		if ( !eventHandle ) {
2922			elemData.handle = eventHandle = function( e ) {
2923				// Discard the second event of a jQuery.event.trigger() and
2924				// when an event is called after a page has unloaded
2925				return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
2926					jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
2927					undefined;
2928			};
2929			// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
2930			eventHandle.elem = elem;
2931		}
2932
2933		// Handle multiple events separated by a space
2934		// jQuery(...).bind("mouseover mouseout", fn);
2935		types = jQuery.trim( hoverHack(types) ).split( " " );
2936		for ( t = 0; t < types.length; t++ ) {
2937
2938			tns = rtypenamespace.exec( types[t] ) || [];
2939			type = tns[1];
2940			namespaces = ( tns[2] || "" ).split( "." ).sort();
2941
2942			// If event changes its type, use the special event handlers for the changed type
2943			special = jQuery.event.special[ type ] || {};
2944
2945			// If selector defined, determine special event api type, otherwise given type
2946			type = ( selector ? special.delegateType : special.bindType ) || type;
2947
2948			// Update special based on newly reset type
2949			special = jQuery.event.special[ type ] || {};
2950
2951			// handleObj is passed to all event handlers
2952			handleObj = jQuery.extend({
2953				type: type,
2954				origType: tns[1],
2955				data: data,
2956				handler: handler,
2957				guid: handler.guid,
2958				selector: selector,
2959				quick: selector && quickParse( selector ),
2960				namespace: namespaces.join(".")
2961			}, handleObjIn );
2962
2963			// Init the event handler queue if we're the first
2964			handlers = events[ type ];
2965			if ( !handlers ) {
2966				handlers = events[ type ] = [];
2967				handlers.delegateCount = 0;
2968
2969				// Only use addEventListener/attachEvent if the special events handler returns false
2970				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2971					// Bind the global event handler to the element
2972					if ( elem.addEventListener ) {
2973						elem.addEventListener( type, eventHandle, false );
2974
2975					} else if ( elem.attachEvent ) {
2976						elem.attachEvent( "on" + type, eventHandle );
2977					}
2978				}
2979			}
2980
2981			if ( special.add ) {
2982				special.add.call( elem, handleObj );
2983
2984				if ( !handleObj.handler.guid ) {
2985					handleObj.handler.guid = handler.guid;
2986				}
2987			}
2988
2989			// Add to the element's handler list, delegates in front
2990			if ( selector ) {
2991				handlers.splice( handlers.delegateCount++, 0, handleObj );
2992			} else {
2993				handlers.push( handleObj );
2994			}
2995
2996			// Keep track of which events have ever been used, for event optimization
2997			jQuery.event.global[ type ] = true;
2998		}
2999
3000		// Nullify elem to prevent memory leaks in IE
3001		elem = null;
3002	},
3003
3004	global: {},
3005
3006	// Detach an event or set of events from an element
3007	remove: function( elem, types, handler, selector, mappedTypes ) {
3008
3009		var elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
3010			t, tns, type, origType, namespaces, origCount,
3011			j, events, special, handle, eventType, handleObj;
3012
3013		if ( !elemData || !(events = elemData.events) ) {
3014			return;
3015		}
3016
3017		// Once for each type.namespace in types; type may be omitted
3018		types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
3019		for ( t = 0; t < types.length; t++ ) {
3020			tns = rtypenamespace.exec( types[t] ) || [];
3021			type = origType = tns[1];
3022			namespaces = tns[2];
3023
3024			// Unbind all events (on this namespace, if provided) for the element
3025			if ( !type ) {
3026				for ( type in events ) {
3027					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
3028				}
3029				continue;
3030			}
3031
3032			special = jQuery.event.special[ type ] || {};
3033			type = ( selector? special.delegateType : special.bindType ) || type;
3034			eventType = events[ type ] || [];
3035			origCount = eventType.length;
3036			namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
3037
3038			// Remove matching events
3039			for ( j = 0; j < eventType.length; j++ ) {
3040				handleObj = eventType[ j ];
3041
3042				if ( ( mappedTypes || origType === handleObj.origType ) &&
3043					 ( !handler || handler.guid === handleObj.guid ) &&
3044					 ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
3045					 ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
3046					eventType.splice( j--, 1 );
3047
3048					if ( handleObj.selector ) {
3049						eventType.delegateCount--;
3050					}
3051					if ( special.remove ) {
3052						special.remove.call( elem, handleObj );
3053					}
3054				}
3055			}
3056
3057			// Remove generic event handler if we removed something and no more handlers exist
3058			// (avoids potential for endless recursion during removal of special event handlers)
3059			if ( eventType.length === 0 && origCount !== eventType.length ) {
3060				if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
3061					jQuery.removeEvent( elem, type, elemData.handle );
3062				}
3063
3064				delete events[ type ];
3065			}
3066		}
3067
3068		// Remove the expando if it's no longer used
3069		if ( jQuery.isEmptyObject( events ) ) {
3070			handle = elemData.handle;
3071			if ( handle ) {
3072				handle.elem = null;
3073			}
3074
3075			// removeData also checks for emptiness and clears the expando if empty
3076			// so use it instead of delete
3077			jQuery.removeData( elem, [ "events", "handle" ], true );
3078		}
3079	},
3080
3081	// Events that are safe to short-circuit if no handlers are attached.
3082	// Native DOM events should not be added, they may have inline handlers.
3083	customEvent: {
3084		"getData": true,
3085		"setData": true,
3086		"changeData": true
3087	},
3088
3089	trigger: function( event, data, elem, onlyHandlers ) {
3090		// Don't do events on text and comment nodes
3091		if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
3092			return;
3093		}
3094
3095		// Event object or event type
3096		var type = event.type || event,
3097			namespaces = [],
3098			cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType;
3099
3100		// focus/blur morphs to focusin/out; ensure we're not firing them right now
3101		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
3102			return;
3103		}
3104
3105		if ( type.indexOf( "!" ) >= 0 ) {
3106			// Exclusive events trigger only for the exact event (no namespaces)
3107			type = type.slice(0, -1);
3108			exclusive = true;
3109		}
3110
3111		if ( type.indexOf( "." ) >= 0 ) {
3112			// Namespaced trigger; create a regexp to match event type in handle()
3113			namespaces = type.split(".");
3114			type = namespaces.shift();
3115			namespaces.sort();
3116		}
3117
3118		if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
3119			// No jQuery handlers for this event type, and it can't have inline handlers
3120			return;
3121		}
3122
3123		// Caller can pass in an Event, Object, or just an event type string
3124		event = typeof event === "object" ?
3125			// jQuery.Event object
3126			event[ jQuery.expando ] ? event :
3127			// Object literal
3128			new jQuery.Event( type, event ) :
3129			// Just the event type (string)
3130			new jQuery.Event( type );
3131
3132		event.type = type;
3133		event.isTrigger = true;
3134		event.exclusive = exclusive;
3135		event.namespace = namespaces.join( "." );
3136		event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
3137		ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
3138
3139		// Handle a global trigger
3140		if ( !elem ) {
3141
3142			// TODO: Stop taunting the data cache; remove global events and always attach to document
3143			cache = jQuery.cache;
3144			for ( i in cache ) {
3145				if ( cache[ i ].events && cache[ i ].events[ type ] ) {
3146					jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
3147				}
3148			}
3149			return;
3150		}
3151
3152		// Clean up the event in case it is being reused
3153		event.result = undefined;
3154		if ( !event.target ) {
3155			event.target = elem;
3156		}
3157
3158		// Clone any incoming data and prepend the event, creating the handler arg list
3159		data = data != null ? jQuery.makeArray( data ) : [];
3160		data.unshift( event );
3161
3162		// Allow special events to draw outside the lines
3163		special = jQuery.event.special[ type ] || {};
3164		if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
3165			return;
3166		}
3167
3168		// Determine event propagation path in advance, per W3C events spec (#9951)
3169		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
3170		eventPath = [[ elem, special.bindType || type ]];
3171		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
3172
3173			bubbleType = special.delegateType || type;
3174			cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
3175			old = null;
3176			for ( ; cur; cur = cur.parentNode ) {
3177				eventPath.push([ cur, bubbleType ]);
3178				old = cur;
3179			}
3180
3181			// Only add window if we got to document (e.g., not plain obj or detached DOM)
3182			if ( old && old === elem.ownerDocument ) {
3183				eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
3184			}
3185		}
3186
3187		// Fire handlers on the event path
3188		for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
3189
3190			cur = eventPath[i][0];
3191			event.type = eventPath[i][1];
3192
3193			handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
3194			if ( handle ) {
3195				handle.apply( cur, data );
3196			}
3197			// Note that this is a bare JS function and not a jQuery handler
3198			handle = ontype && cur[ ontype ];
3199			if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) {
3200				event.preventDefault();
3201			}
3202		}
3203		event.type = type;
3204
3205		// If nobody prevented the default action, do it now
3206		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
3207
3208			if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
3209				!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
3210
3211				// Call a native DOM method on the target with the same name name as the event.
3212				// Can't use an .isFunction() check here because IE6/7 fails that test.
3213				// Don't do default actions on window, that's where global variables be (#6170)
3214				// IE<9 dies on focus/blur to hidden element (#1486)
3215				if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
3216
3217					// Don't re-trigger an onFOO event when we call its FOO() method
3218					old = elem[ ontype ];
3219
3220					if ( old ) {
3221						elem[ ontype ] = null;
3222					}
3223
3224					// Prevent re-triggering of the same event, since we already bubbled it above
3225					jQuery.event.triggered = type;
3226					elem[ type ]();
3227					jQuery.event.triggered = undefined;
3228
3229					if ( old ) {
3230						elem[ ontype ] = old;
3231					}
3232				}
3233			}
3234		}
3235
3236		return event.result;
3237	},
3238
3239	dispatch: function( event ) {
3240
3241		// Make a writable jQuery.Event from the native event object
3242		event = jQuery.event.fix( event || window.event );
3243
3244		var handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
3245			delegateCount = handlers.delegateCount,
3246			args = [].slice.call( arguments, 0 ),
3247			run_all = !event.exclusive && !event.namespace,
3248			special = jQuery.event.special[ event.type ] || {},
3249			handlerQueue = [],
3250			i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related;
3251
3252		// Use the fix-ed jQuery.Event rather than the (read-only) native event
3253		args[0] = event;
3254		event.delegateTarget = this;
3255
3256		// Call the preDispatch hook for the mapped type, and let it bail if desired
3257		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
3258			return;
3259		}
3260
3261		// Determine handlers that should run if there are delegated events