https://www.clearandbrilliant.com.hk/Static/js/jquery.js

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

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

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