https://www.virtuscastenedolo.it/js/jquery.js?lu=29072026191724

1/*!
2 * jQuery JavaScript Library v1.6.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: Thu Jun 30 14:16:56 2011 -0400
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	// (both of which we optimize for)
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	// Check for digits
51	rdigit = /\d/,
52
53	// Match a standalone tag
54	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
55
56	// JSON RegExp
57	rvalidchars = /^[\],:{}\s]*$/,
58	rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
59	rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
60	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
61
62	// Useragent RegExp
63	rwebkit = /(webkit)[ \/]([\w.]+)/,
64	ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
65	rmsie = /(msie) ([\w.]+)/,
66	rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
67
68	// Matches dashed string for camelizing
69	rdashAlpha = /-([a-z])/ig,
70
71	// Used by jQuery.camelCase as callback to replace()
72	fcamelCase = function( all, letter ) {
73		return letter.toUpperCase();
74	},
75
76	// Keep a UserAgent string for use with jQuery.browser
77	userAgent = navigator.userAgent,
78
79	// For matching the engine and version of the browser
80	browserMatch,
81
82	// The deferred used on DOM ready
83	readyList,
84
85	// The ready event handler
86	DOMContentLoaded,
87
88	// Save a reference to some core methods
89	toString = Object.prototype.toString,
90	hasOwn = Object.prototype.hasOwnProperty,
91	push = Array.prototype.push,
92	slice = Array.prototype.slice,
93	trim = String.prototype.trim,
94	indexOf = Array.prototype.indexOf,
95
96	// [[Class]] -> type pairs
97	class2type = {};
98
99jQuery.fn = jQuery.prototype = {
100	constructor: jQuery,
101	init: function( selector, context, rootjQuery ) {
102		var match, elem, ret, doc;
103
104		// Handle $(""), $(null), or $(undefined)
105		if ( !selector ) {
106			return this;
107		}
108
109		// Handle $(DOMElement)
110		if ( selector.nodeType ) {
111			this.context = this[0] = selector;
112			this.length = 1;
113			return this;
114		}
115
116		// The body element only exists once, optimize finding it
117		if ( selector === "body" && !context && document.body ) {
118			this.context = document;
119			this[0] = document.body;
120			this.selector = selector;
121			this.length = 1;
122			return this;
123		}
124
125		// Handle HTML strings
126		if ( typeof selector === "string" ) {
127			// Are we dealing with HTML string or an ID?
128			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
129				// Assume that strings that start and end with <> are HTML and skip the regex check
130				match = [ null, selector, null ];
131
132			} else {
133				match = quickExpr.exec( selector );
134			}
135
136			// Verify a match, and that no context was specified for #id
137			if ( match && (match[1] || !context) ) {
138
139				// HANDLE: $(html) -> $(array)
140				if ( match[1] ) {
141					context = context instanceof jQuery ? context[0] : context;
142					doc = (context ? context.ownerDocument || context : document);
143
144					// If a single string is passed in and it's a single tag
145					// just do a createElement and skip the rest
146					ret = rsingleTag.exec( selector );
147
148					if ( ret ) {
149						if ( jQuery.isPlainObject( context ) ) {
150							selector = [ document.createElement( ret[1] ) ];
151							jQuery.fn.attr.call( selector, context, true );
152
153						} else {
154							selector = [ doc.createElement( ret[1] ) ];
155						}
156
157					} else {
158						ret = jQuery.buildFragment( [ match[1] ], [ doc ] );

159						selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
160					}
161
162					return jQuery.merge( this, selector );
163
164				// HANDLE: $("#id")
165				} else {
166					elem = document.getElementById( match[2] );
167
168					// Check parentNode to catch when Blackberry 4.6 returns
169					// nodes that are no longer in the document #6963
170					if ( elem && elem.parentNode ) {
171						// Handle the case where IE and Opera return items
172						// by name instead of ID
173						if ( elem.id !== match[2] ) {
174							return rootjQuery.find( selector );
175						}
176
177						// Otherwise, we inject the element directly into the jQuery object
178						this.length = 1;
179						this[0] = elem;
180					}
181
182					this.context = document;
183					this.selector = selector;
184					return this;
185				}
186
187			// HANDLE: $(expr, $(...))
188			} else if ( !context || context.jquery ) {
189				return (context || rootjQuery).find( selector );
190
191			// HANDLE: $(expr, context)
192			// (which is just equivalent to: $(context).find(expr)
193			} else {
194				return this.constructor( context ).find( selector );
195			}
196
197		// HANDLE: $(function)
198		// Shortcut for document ready
199		} else if ( jQuery.isFunction( selector ) ) {
200			return rootjQuery.ready( selector );
201		}
202
203		if (selector.selector !== undefined) {
204			this.selector = selector.selector;
205			this.context = selector.context;
206		}
207
208		return jQuery.makeArray( selector, this );
209	},
210
211	// Start with an empty selector
212	selector: "",
213
214	// The current version of jQuery being used
215	jquery: "1.6.2",
216
217	// The default length of a jQuery object is 0
218	length: 0,
219
220	// The number of elements contained in the matched element set
221	size: function() {
222		return this.length;
223	},
224
225	toArray: function() {
226		return slice.call( this, 0 );
227	},
228
229	// Get the Nth element in the matched element set OR
230	// Get the whole matched element set as a clean array
231	get: function( num ) {
232		return num == null ?
233
234			// Return a 'clean' array
235			this.toArray() :
236
237			// Return just the object
238			( num < 0 ? this[ this.length + num ] : this[ num ] );
239	},
240
241	// Take an array of elements and push it onto the stack
242	// (returning the new matched element set)
243	pushStack: function( elems, name, selector ) {
244		// Build a new jQuery matched element set
245		var ret = this.constructor();
246
247		if ( jQuery.isArray( elems ) ) {
248			push.apply( ret, elems );
249
250		} else {
251			jQuery.merge( ret, elems );
252		}
253
254		// Add the old object onto the stack (as a reference)
255		ret.prevObject = this;
256
257		ret.context = this.context;
258
259		if ( name === "find" ) {
260			ret.selector = this.selector + (this.selector ? " " : "") + selector;
261		} else if ( name ) {
262			ret.selector = this.selector + "." + name + "(" + selector + ")";
263		}
264
265		// Return the newly-formed element set
266		return ret;
267	},
268
269	// Execute a callback for every element in the matched set.
270	// (You can seed the arguments with an array of args, but this is
271	// only used internally.)
272	each: function( callback, args ) {
273		return jQuery.each( this, callback, args );
274	},
275
276	ready: function( fn ) {
277		// Attach the listeners
278		jQuery.bindReady();
279
280		// Add the callback
281		readyList.done( fn );
282
283		return this;
284	},
285
286	eq: function( i ) {
287		return i === -1 ?
288			this.slice( i ) :
289			this.slice( i, +i + 1 );
290	},
291
292	first: function() {
293		return this.eq( 0 );
294	},
295
296	last: function() {
297		return this.eq( -1 );
298	},
299
300	slice: function() {
301		return this.pushStack( slice.apply( this, arguments ),
302			"slice", slice.call(arguments).join(",") );
303	},
304
305	map: function( callback ) {
306		return this.pushStack( jQuery.map(this, function( elem, i ) {
307			return callback.call( elem, i, elem );
308		}));
309	},
310
311	end: function() {
312		return this.prevObject || this.constructor(null);
313	},
314
315	// For internal use only.
316	// Behaves like an Array's method, not like a jQuery method.
317	push: push,
318	sort: [].sort,
319	splice: [].splice
320};
321
322// Give the init function the jQuery prototype for later instantiation
323jQuery.fn.init.prototype = jQuery.fn;
324
325jQuery.extend = jQuery.fn.extend = function() {
326	var options, name, src, copy, copyIsArray, clone,
327		target = arguments[0] || {},
328		i = 1,
329		length = arguments.length,
330		deep = false;
331
332	// Handle a deep copy situation
333	if ( typeof target === "boolean" ) {
334		deep = target;
335		target = arguments[1] || {};
336		// skip the boolean and the target
337		i = 2;
338	}
339
340	// Handle case when target is a string or something (possible in deep copy)
341	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
342		target = {};
343	}
344
345	// extend jQuery itself if only one argument is passed
346	if ( length === i ) {
347		target = this;
348		--i;
349	}
350
351	for ( ; i < length; i++ ) {
352		// Only deal with non-null/undefined values
353		if ( (options = arguments[ i ]) != null ) {
354			// Extend the base object
355			for ( name in options ) {
356				src = target[ name ];
357				copy = options[ name ];
358
359				// Prevent never-ending loop
360				if ( target === copy ) {
361					continue;
362				}
363
364				// Recurse if we're merging plain objects or arrays
365				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
366					if ( copyIsArray ) {
367						copyIsArray = false;
368						clone = src && jQuery.isArray(src) ? src : [];
369
370					} else {
371						clone = src && jQuery.isPlainObject(src) ? src : {};
372					}
373
374					// Never move original objects, clone them
375					target[ name ] = jQuery.extend( deep, clone, copy );
376
377				// Don't bring in undefined values
378				} else if ( copy !== undefined ) {
379					target[ name ] = copy;
380				}
381			}
382		}
383	}
384
385	// Return the modified object
386	return target;
387};
388
389jQuery.extend({
390	noConflict: function( deep ) {
391		if ( window.$ === jQuery ) {
392			window.$ = _$;
393		}
394
395		if ( deep && window.jQuery === jQuery ) {
396			window.jQuery = _jQuery;
397		}
398
399		return jQuery;
400	},
401
402	// Is the DOM ready to be used? Set to true once it occurs.
403	isReady: false,
404
405	// A counter to track how many items to wait for before
406	// the ready event fires. See #6781
407	readyWait: 1,
408
409	// Hold (or release) the ready event
410	holdReady: function( hold ) {
411		if ( hold ) {
412			jQuery.readyWait++;
413		} else {
414			jQuery.ready( true );
415		}
416	},
417
418	// Handle when the DOM is ready
419	ready: function( wait ) {
420		// Either a released hold or an DOMready/load event and not yet ready
421		if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
422			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
423			if ( !document.body ) {
424				return setTimeout( jQuery.ready, 1 );
425			}
426
427			// Remember that the DOM is ready
428			jQuery.isReady = true;
429
430			// If a normal DOM Ready event fired, decrement, and wait if need be
431			if ( wait !== true && --jQuery.readyWait > 0 ) {
432				return;
433			}
434
435			// If there are functions bound, to execute
436			readyList.resolveWith( document, [ jQuery ] );
437
438			// Trigger any bound ready events
439			if ( jQuery.fn.trigger ) {
440				jQuery( document ).trigger( "ready" ).unbind( "ready" );
441			}
442		}
443	},
444
445	bindReady: function() {
446		if ( readyList ) {
447			return;
448		}
449
450		readyList = jQuery._Deferred();
451
452		// Catch cases where $(document).ready() is called after the
453		// browser event has already occurred.
454		if ( document.readyState === "complete" ) {
455			// Handle it asynchronously to allow scripts the opportunity to delay ready
456			return setTimeout( jQuery.ready, 1 );
457		}
458
459		// Mozilla, Opera and webkit nightlies currently support this event
460		if ( document.addEventListener ) {
461			// Use the handy event callback
462			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
463
464
465			// A fallback to window.onload, that will always work
466			window.addEventListener( "load", jQuery.ready, false );
467
468		// If IE event model is used
469		} else if ( document.attachEvent ) {
470			// ensure firing before onload,
471			// maybe late but safe also for iframes
472			document.attachEvent( "onreadystatechange", DOMContentLoaded );
473
474			// A fallback to window.onload, that will always work
475			window.attachEvent( "onload", jQuery.ready );
476
477			// If IE and not a frame
478			// continually check to see if the document is ready
479			var toplevel = false;
480
481			try {
482				toplevel = window.frameElement == null;
483			} catch(e) {}
484
485			if ( document.documentElement.doScroll && toplevel ) {
486				doScrollCheck();
487			}
488		}
489	},
490
491	// See test/unit/core.js for details concerning isFunction.
492	// Since version 1.3, DOM methods and functions like alert
493	// aren't supported. They return false on IE (#2968).
494	isFunction: function( obj ) {
495		return jQuery.type(obj) === "function";
496	},
497
498	isArray: Array.isArray || function( obj ) {
499		return jQuery.type(obj) === "array";
500	},
501
502	// A crude way of determining if an object is a window
503	isWindow: function( obj ) {
504		return obj && typeof obj === "object" && "setInterval" in obj;
505	},
506
507	isNaN: function( obj ) {
508		return obj == null || !rdigit.test( obj ) || isNaN( obj );
509	},
510
511	type: function( obj ) {
512		return obj == null ?
513			String( obj ) :
514			class2type[ toString.call(obj) ] || "object";
515	},
516
517	isPlainObject: function( obj ) {
518		// Must be an Object.
519		// Because of IE, we also have to check the presence of the constructor property.
520		// Make sure that DOM nodes and window objects don't pass through, as well
521		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
522			return false;
523		}
524
525		// Not own constructor property must be Object
526		if ( obj.constructor &&
527			!hasOwn.call(obj, "constructor") &&
528			!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
529			return false;
530		}
531
532		// Own properties are enumerated firstly, so to speed up,
533		// if last one is own, then all properties are own.
534
535		var key;
536		for ( key in obj ) {}
537
538		return key === undefined || hasOwn.call( obj, key );
539	},
540
541	isEmptyObject: function( obj ) {
542		for ( var name in obj ) {
543			return false;
544		}
545		return true;
546	},
547
548	error: function( msg ) {
549		throw msg;
550	},
551
552	parseJSON: function( data ) {
553		if ( typeof data !== "string" || !data ) {
554			return null;
555		}
556
557		// Make sure leading/trailing whitespace is removed (IE can't handle it)
558		data = jQuery.trim( data );
559
560		// Attempt to parse using the native JSON parser first
561		if ( window.JSON && window.JSON.parse ) {
562			return window.JSON.parse( data );
563		}
564
565		// Make sure the incoming data is actual JSON
566		// Logic borrowed from http://json.org/json2.js
567		if ( rvalidchars.test( data.replace( rvalidescape, "@" )
568			.replace( rvalidtokens, "]" )
569			.replace( rvalidbraces, "")) ) {
570
571			return (new Function( "return " + data ))();
572
573		}
574		jQuery.error( "Invalid JSON: " + data );
575	},
576
577	// Cross-browser xml parsing
578	// (xml & tmp used internally)
579	parseXML: function( data , xml , tmp ) {
580
581		if ( window.DOMParser ) { // Standard
582			tmp = new DOMParser();
583			xml = tmp.parseFromString( data , "text/xml" );
584		} else { // IE
585			xml = new ActiveXObject( "Microsoft.XMLDOM" );
586			xml.async = "false";
587			xml.loadXML( data );
588		}
589
590		tmp = xml.documentElement;
591
592		if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
593			jQuery.error( "Invalid XML: " + data );
594		}
595
596		return xml;
597	},
598
599	noop: function() {},
600
601	// Evaluates a script in a global context
602	// Workarounds based on findings by Jim Driscoll
603	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
604	globalEval: function( data ) {
605		if ( data && rnotwhite.test( data ) ) {
606			// We use execScript on Internet Explorer
607			// We use an anonymous function so that context is window
608			// rather than jQuery in Firefox
609			( window.execScript || function( data ) {
610				window[ "eval" ].call( window, data );
611			} )( data );
612		}
613	},
614
615	// Converts a dashed string to camelCased string;
616	// Used by both the css and data modules
617	camelCase: function( string ) {
618		return string.replace( rdashAlpha, fcamelCase );
619	},
620
621	nodeName: function( elem, name ) {
622		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
623	},
624
625	// args is for internal usage only
626	each: function( object, callback, args ) {
627		var name, i = 0,
628			length = object.length,
629			isObj = length === undefined || jQuery.isFunction( object );
630
631		if ( args ) {
632			if ( isObj ) {
633				for ( name in object ) {
634					if ( callback.apply( object[ name ], args ) === false ) {
635						break;
636					}
637				}
638			} else {
639				for ( ; i < length; ) {
640					if ( callback.apply( object[ i++ ], args ) === false ) {
641						break;
642					}
643				}
644			}
645
646		// A special, fast, case for the most common use of each
647		} else {
648			if ( isObj ) {
649				for ( name in object ) {
650					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
651						break;
652					}
653				}
654			} else {
655				for ( ; i < length; ) {
656					if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
657						break;
658					}
659				}
660			}
661		}
662
663		return object;
664	},
665
666	// Use native String.trim function wherever possible
667	trim: trim ?
668		function( text ) {
669			return text == null ?
670				"" :
671				trim.call( text );
672		} :
673
674		// Otherwise use our own trimming functionality
675		function( text ) {
676			return text == null ?
677				"" :
678				text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
679		},
680
681	// results is for internal usage only
682	makeArray: function( array, results ) {
683		var ret = results || [];
684
685		if ( array != null ) {
686			// The window, strings (and functions) also have 'length'
687			// The extra typeof function check is to prevent crashes
688			// in Safari 2 (See: #3039)
689			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
690			var type = jQuery.type( array );
691
692			if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
693				push.call( ret, array );
694			} else {
695				jQuery.merge( ret, array );
696			}
697		}
698
699		return ret;
700	},
701
702	inArray: function( elem, array ) {
703
704		if ( indexOf ) {
705			return indexOf.call( array, elem );
706		}
707
708		for ( var i = 0, length = array.length; i < length; i++ ) {
709			if ( array[ i ] === elem ) {
710				return i;
711			}
712		}
713
714		return -1;
715	},
716
717	merge: function( first, second ) {
718		var i = first.length,
719			j = 0;
720
721		if ( typeof second.length === "number" ) {
722			for ( var l = second.length; j < l; j++ ) {
723				first[ i++ ] = second[ j ];
724			}
725
726		} else {
727			while ( second[j] !== undefined ) {
728				first[ i++ ] = second[ j++ ];
729			}
730		}
731
732		first.length = i;
733
734		return first;
735	},
736
737	grep: function( elems, callback, inv ) {
738		var ret = [], retVal;
739		inv = !!inv;
740
741		// Go through the array, only saving the items
742		// that pass the validator function
743		for ( var i = 0, length = elems.length; i < length; i++ ) {
744			retVal = !!callback( elems[ i ], i );
745			if ( inv !== retVal ) {

746				ret.push( elems[ i ] );
747			}
748		}
749
750		return ret;
751	},
752
753	// arg is for internal usage only
754	map: function( elems, callback, arg ) {
755		var value, key, ret = [],
756			i = 0,
757			length = elems.length,
758			// jquery objects are treated as arrays
759			isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
760
761		// Go through the array, translating each of the items to their
762		if ( isArray ) {
763			for ( ; i < length; i++ ) {
764				value = callback( elems[ i ], i, arg );
765
766				if ( value != null ) {
767					ret[ ret.length ] = value;
768				}
769			}
770
771		// Go through every key on the object,
772		} else {
773			for ( key in elems ) {
774				value = callback( elems[ key ], key, arg );
775
776				if ( value != null ) {
777					ret[ ret.length ] = value;
778				}
779			}
780		}
781
782		// Flatten any nested arrays
783		return ret.concat.apply( [], ret );
784	},
785
786	// A global GUID counter for objects
787	guid: 1,
788
789	// Bind a function to a context, optionally partially applying any
790	// arguments.
791	proxy: function( fn, context ) {
792		if ( typeof context === "string" ) {
793			var tmp = fn[ context ];
794			context = fn;
795			fn = tmp;
796		}
797
798		// Quick check to determine if target is callable, in the spec
799		// this throws a TypeError, but we will just return undefined.
800		if ( !jQuery.isFunction( fn ) ) {
801			return undefined;
802		}
803
804		// Simulated bind
805		var args = slice.call( arguments, 2 ),
806			proxy = function() {
807				return fn.apply( context, args.concat( slice.call( arguments ) ) );
808			};
809
810		// Set the guid of unique handler to the same of original handler, so it can be removed
811		proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
812
813		return proxy;
814	},
815
816	// Mutifunctional method to get and set values to a collection
817	// The value/s can optionally be executed if it's a function
818	access: function( elems, key, value, exec, fn, pass ) {
819		var length = elems.length;
820
821		// Setting many attributes
822		if ( typeof key === "object" ) {
823			for ( var k in key ) {
824				jQuery.access( elems, k, key[k], exec, fn, value );
825			}
826			return elems;
827		}
828
829		// Setting one attribute
830		if ( value !== undefined ) {
831			// Optionally, function values get executed if exec is true
832			exec = !pass && exec && jQuery.isFunction(value);
833
834			for ( var i = 0; i < length; i++ ) {
835				fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
836			}
837
838			return elems;
839		}
840
841		// Getting an attribute
842		return length ? fn( elems[0], key ) : undefined;
843	},
844
845	now: function() {
846		return (new Date()).getTime();
847	},
848
849	// Use of jQuery.browser is frowned upon.
850	// More details: http://docs.jquery.com/Utilities/jQuery.browser
851	uaMatch: function( ua ) {
852		ua = ua.toLowerCase();
853
854		var match = rwebkit.exec( ua ) ||
855			ropera.exec( ua ) ||
856			rmsie.exec( ua ) ||
857			ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
858			[];
859
860		return { browser: match[1] || "", version: match[2] || "0" };
861	},
862
863	sub: function() {
864		function jQuerySub( selector, context ) {
865			return new jQuerySub.fn.init( selector, context );
866		}
867		jQuery.extend( true, jQuerySub, this );
868		jQuerySub.superclass = this;
869		jQuerySub.fn = jQuerySub.prototype = this();
870		jQuerySub.fn.constructor = jQuerySub;
871		jQuerySub.sub = this.sub;
872		jQuerySub.fn.init = function init( selector, context ) {
873			if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
874				context = jQuerySub( context );
875			}
876
877			return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
878		};
879		jQuerySub.fn.init.prototype = jQuerySub.fn;
880		var rootjQuerySub = jQuerySub(document);
881		return jQuerySub;
882	},
883
884	browser: {}
885});
886
887// Populate the class2type map
888jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
889	class2type[ "[object " + name + "]" ] = name.toLowerCase();
890});
891
892browserMatch = jQuery.uaMatch( userAgent );
893if ( browserMatch.browser ) {
894	jQuery.browser[ browserMatch.browser ] = true;
895	jQuery.browser.version = browserMatch.version;
896}
897
898// Deprecated, use jQuery.browser.webkit instead
899if ( jQuery.browser.webkit ) {
900	jQuery.browser.safari = true;
901}
902

903// IE doesn't match non-breaking spaces with \s
904if ( rnotwhite.test( "\xA0" ) ) {
905	trimLeft = /^[\s\xA0]+/;
906	trimRight = /[\s\xA0]+$/;
907}
908
909// All jQuery objects should point back to these
910rootjQuery = jQuery(document);
911
912// Cleanup functions for the document ready method
913if ( document.addEventListener ) {
914	DOMContentLoaded = function() {
915		document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
916		jQuery.ready();
917	};
918
919} else if ( document.attachEvent ) {
920	DOMContentLoaded = function() {
921		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
922		if ( document.readyState === "complete" ) {
923			document.detachEvent( "onreadystatechange", DOMContentLoaded );
924			jQuery.ready();
925		}
926	};
927}
928
929// The DOM ready check for Internet Explorer
930function doScrollCheck() {
931	if ( jQuery.isReady ) {
932		return;
933	}
934
935	try {
936		// If IE is used, use the trick by Diego Perini
937		// http://javascript.nwbox.com/IEContentLoaded/
938		document.documentElement.doScroll("left");
939	} catch(e) {
940		setTimeout( doScrollCheck, 1 );
941		return;
942	}
943
944	// and execute any waiting functions
945	jQuery.ready();
946}
947
948return jQuery;
949
950})();
951
952
953var // Promise methods
954	promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ),
955	// Static reference to slice
956	sliceDeferred = [].slice;
957
958jQuery.extend({
959	// Create a simple deferred (one callbacks list)
960	_Deferred: function() {
961		var // callbacks list
962			callbacks = [],
963			// stored [ context , args ]
964			fired,
965			// to avoid firing when already doing so
966			firing,
967			// flag to know if the deferred has been cancelled
968			cancelled,
969			// the deferred itself
970			deferred  = {
971
972				// done( f1, f2, ...)
973				done: function() {
974					if ( !cancelled ) {
975						var args = arguments,
976							i,
977							length,
978							elem,
979							type,
980							_fired;
981						if ( fired ) {
982							_fired = fired;
983							fired = 0;
984						}
985						for ( i = 0, length = args.length; i < length; i++ ) {
986							elem = args[ i ];
987							type = jQuery.type( elem );
988							if ( type === "array" ) {
989								deferred.done.apply( deferred, elem );
990							} else if ( type === "function" ) {
991								callbacks.push( elem );
992							}
993						}
994						if ( _fired ) {
995							deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
996						}
997					}
998					return this;
999				},
1000
1001				// resolve with given context and args
1002				resolveWith: function( context, args ) {
1003					if ( !cancelled && !fired && !firing ) {
1004						// make sure args are available (#8421)
1005						args = args || [];
1006						firing = 1;
1007						try {
1008							while( callbacks[ 0 ] ) {
1009								callbacks.shift().apply( context, args );
1010							}
1011						}
1012						finally {
1013							fired = [ context, args ];
1014							firing = 0;
1015						}
1016					}
1017					return this;
1018				},
1019
1020				// resolve with this as context and given arguments
1021				resolve: function() {
1022					deferred.resolveWith( this, arguments );
1023					return this;
1024				},
1025
1026				// Has this deferred been resolved?
1027				isResolved: function() {
1028					return !!( firing || fired );
1029				},
1030
1031				// Cancel
1032				cancel: function() {
1033					cancelled = 1;
1034					callbacks = [];
1035					return this;
1036				}
1037			};
1038
1039		return deferred;
1040	},
1041
1042	// Full fledged deferred (two callbacks list)
1043	Deferred: function( func ) {
1044		var deferred = jQuery._Deferred(),
1045			failDeferred = jQuery._Deferred(),
1046			promise;
1047		// Add errorDeferred methods, then and promise
1048		jQuery.extend( deferred, {
1049			then: function( doneCallbacks, failCallbacks ) {
1050				deferred.done( doneCallbacks ).fail( failCallbacks );
1051				return this;
1052			},
1053			always: function() {
1054				return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments );
1055			},
1056			fail: failDeferred.done,
1057			rejectWith: failDeferred.resolveWith,
1058			reject: failDeferred.resolve,
1059			isRejected: failDeferred.isResolved,
1060			pipe: function( fnDone, fnFail ) {
1061				return jQuery.Deferred(function( newDefer ) {
1062					jQuery.each( {
1063						done: [ fnDone, "resolve" ],
1064						fail: [ fnFail, "reject" ]
1065					}, function( handler, data ) {
1066						var fn = data[ 0 ],
1067							action = data[ 1 ],
1068							returned;
1069						if ( jQuery.isFunction( fn ) ) {
1070							deferred[ handler ](function() {
1071								returned = fn.apply( this, arguments );
1072								if ( returned && jQuery.isFunction( returned.promise ) ) {
1073									returned.promise().then( newDefer.resolve, newDefer.reject );
1074								} else {
1075									newDefer[ action ]( returned );
1076								}
1077							});

1078						} else {
1079							deferred[ handler ]( newDefer[ action ] );
1080						}
1081					});
1082				}).promise();
1083			},
1084			// Get a promise for this deferred
1085			// If obj is provided, the promise aspect is added to the object
1086			promise: function( obj ) {
1087				if ( obj == null ) {
1088					if ( promise ) {
1089						return promise;
1090					}
1091					promise = obj = {};
1092				}
1093				var i = promiseMethods.length;
1094				while( i-- ) {
1095					obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
1096				}
1097				return obj;
1098			}
1099		});
1100		// Make sure only one callback list will be used
1101		deferred.done( failDeferred.cancel ).fail( deferred.cancel );
1102		// Unexpose cancel
1103		delete deferred.cancel;
1104		// Call given func if any
1105		if ( func ) {
1106			func.call( deferred, deferred );
1107		}
1108		return deferred;
1109	},
1110
1111	// Deferred helper
1112	when: function( firstParam ) {
1113		var args = arguments,
1114			i = 0,
1115			length = args.length,
1116			count = length,
1117			deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
1118				firstParam :
1119				jQuery.Deferred();
1120		function resolveFunc( i ) {
1121			return function( value ) {
1122				args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1123				if ( !( --count ) ) {
1124					// Strange bug in FF4:
1125					// Values changed onto the arguments object sometimes end up as undefined values
1126					// outside the $.when method. Cloning the object into a fresh array solves the issue
1127					deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) );
1128				}
1129			};
1130		}
1131		if ( length > 1 ) {
1132			for( ; i < length; i++ ) {
1133				if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) {
1134					args[ i ].promise().then( resolveFunc(i), deferred.reject );
1135				} else {
1136					--count;
1137				}
1138			}
1139			if ( !count ) {
1140				deferred.resolveWith( deferred, args );
1141			}
1142		} else if ( deferred !== firstParam ) {
1143			deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
1144		}
1145		return deferred.promise();
1146	}
1147});
1148
1149
1150
1151jQuery.support = (function() {
1152
1153	var div = document.createElement( "div" ),
1154		documentElement = document.documentElement,
1155		all,
1156		a,
1157		select,
1158		opt,
1159		input,
1160		marginDiv,
1161		support,
1162		fragment,
1163		body,
1164		testElementParent,
1165		testElement,
1166		testElementStyle,
1167		tds,
1168		events,
1169		eventName,
1170		i,
1171		isSupported;
1172
1173	// Preliminary tests
1174	div.setAttribute("className", "t");
1175	div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
1176
1177	all = div.getElementsByTagName( "*" );
1178	a = div.getElementsByTagName( "a" )[ 0 ];
1179
1180	// Can't get basic test support
1181	if ( !all || !all.length || !a ) {
1182		return {};
1183	}
1184
1185	// First batch of supports tests
1186	select = document.createElement( "select" );
1187	opt = select.appendChild( document.createElement("option") );
1188	input = div.getElementsByTagName( "input" )[ 0 ];
1189
1190	support = {
1191		// IE strips leading whitespace when .innerHTML is used
1192		leadingWhitespace: ( div.firstChild.nodeType === 3 ),
1193
1194		// Make sure that tbody elements aren't automatically inserted
1195		// IE will insert them into empty tables
1196		tbody: !div.getElementsByTagName( "tbody" ).length,
1197
1198		// Make sure that link elements get serialized correctly by innerHTML
1199		// This requires a wrapper element in IE
1200		htmlSerialize: !!div.getElementsByTagName( "link" ).length,
1201
1202		// Get the style information from getAttribute
1203		// (IE uses .cssText instead)
1204		style: /top/.test( a.getAttribute("style") ),
1205
1206		// Make sure that URLs aren't manipulated
1207		// (IE normalizes it by default)
1208		hrefNormalized: ( a.getAttribute( "href" ) === "/a" ),
1209
1210		// Make sure that element opacity exists
1211		// (IE uses filter instead)
1212		// Use a regex to work around a WebKit issue. See #5145
1213		opacity: /^0.55$/.test( a.style.opacity ),
1214
1215		// Verify style float existence
1216		// (IE uses styleFloat instead of cssFloat)
1217		cssFloat: !!a.style.cssFloat,
1218
1219		// Make sure that if no value is specified for a checkbox
1220		// that it defaults to "on".
1221		// (WebKit defaults to "" instead)
1222		checkOn: ( input.value === "on" ),
1223
1224		// Make sure that a selected-by-default option has a working selected property.
1225		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1226		optSelected: opt.selected,
1227
1228		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1229		getSetAttribute: div.className !== "t",
1230
1231		// Will be defined later
1232		submitBubbles: true,
1233		changeBubbles: true,
1234		focusinBubbles: false,
1235		deleteExpando: true,
1236		noCloneEvent: true,
1237		inlineBlockNeedsLayout: false,
1238		shrinkWrapBlocks: false,
1239		reliableMarginRight: true
1240	};
1241
1242	// Make sure checked status is properly cloned
1243	input.checked = true;
1244	support.noCloneChecked = input.cloneNode( true ).checked;
1245
1246	// Make sure that the options inside disabled selects aren't marked as disabled
1247	// (WebKit marks them as disabled)
1248	select.disabled = true;
1249	support.optDisabled = !opt.disabled;
1250
1251	// Test to see if it's possible to delete an expando from an element
1252	// Fails in Internet Explorer
1253	try {
1254		delete div.test;
1255	} catch( e ) {
1256		support.deleteExpando = false;
1257	}
1258
1259	if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1260		div.attachEvent( "onclick", function() {
1261			// Cloning a node shouldn't copy over any
1262			// bound event handlers (IE does this)
1263			support.noCloneEvent = false;
1264		});
1265		div.cloneNode( true ).fireEvent( "onclick" );
1266	}
1267
1268	// Check if a radio maintains it's value
1269	// after being appended to the DOM
1270	input = document.createElement("input");
1271	input.value = "t";
1272	input.setAttribute("type", "radio");
1273	support.radioValue = input.value === "t";
1274
1275	input.setAttribute("checked", "checked");
1276	div.appendChild( input );
1277	fragment = document.createDocumentFragment();
1278	fragment.appendChild( div.firstChild );
1279
1280	// WebKit doesn't clone checked state correctly in fragments
1281	support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
1282
1283	div.innerHTML = "";
1284
1285	// Figure out if the W3C box model works as expected
1286	div.style.width = div.style.paddingLeft = "1px";
1287
1288	body = document.getElementsByTagName( "body" )[ 0 ];
1289	// We use our own, invisible, body unless the body is already present
1290	// in which case we use a div (#9239)
1291	testElement = document.createElement( body ? "div" : "body" );
1292	testElementStyle = {
1293		visibility: "hidden",
1294		width: 0,
1295		height: 0,
1296		border: 0,
1297		margin: 0
1298	};
1299	if ( body ) {
1300		jQuery.extend( testElementStyle, {
1301			position: "absolute",

1302			left: -1000,
1303			top: -1000
1304		});
1305	}
1306	for ( i in testElementStyle ) {
1307		testElement.style[ i ] = testElementStyle[ i ];
1308	}
1309	testElement.appendChild( div );
1310	testElementParent = body || documentElement;
1311	testElementParent.insertBefore( testElement, testElementParent.firstChild );
1312
1313	// Check if a disconnected checkbox will retain its checked
1314	// value of true after appended to the DOM (IE6/7)
1315	support.appendChecked = input.checked;
1316
1317	support.boxModel = div.offsetWidth === 2;
1318
1319	if ( "zoom" in div.style ) {
1320		// Check if natively block-level elements act like inline-block
1321		// elements when setting their display to 'inline' and giving
1322		// them layout
1323		// (IE < 8 does this)
1324		div.style.display = "inline";
1325		div.style.zoom = 1;
1326		support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
1327
1328		// Check if elements with layout shrink-wrap their children
1329		// (IE 6 does this)
1330		div.style.display = "";
1331		div.innerHTML = "<div style='width:4px;'></div>";
1332		support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
1333	}
1334
1335	div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
1336	tds = div.getElementsByTagName( "td" );
1337
1338	// Check if table cells still have offsetWidth/Height when they are set
1339	// to display:none and there are still other visible table cells in a
1340	// table row; if so, offsetWidth/Height are not reliable for use when
1341	// determining if an element has been hidden directly using
1342	// display:none (it is still safe to use offsets if a parent element is
1343	// hidden; don safety goggles and see bug #4512 for more information).
1344	// (only IE 8 fails this test)
1345	isSupported = ( tds[ 0 ].offsetHeight === 0 );
1346
1347	tds[ 0 ].style.display = "";
1348	tds[ 1 ].style.display = "none";
1349
1350	// Check if empty table cells still have offsetWidth/Height
1351	// (IE < 8 fail this test)
1352	support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1353	div.innerHTML = "";
1354
1355	// Check if div with explicit width and no margin-right incorrectly
1356	// gets computed margin-right based on width of container. For more
1357	// info see bug #3333
1358	// Fails in WebKit before Feb 2011 nightlies
1359	// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1360	if ( document.defaultView && document.defaultView.getComputedStyle ) {
1361		marginDiv = document.createElement( "div" );
1362		marginDiv.style.width = "0";
1363		marginDiv.style.marginRight = "0";
1364		div.appendChild( marginDiv );
1365		support.reliableMarginRight =
1366			( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
1367	}
1368
1369	// Remove the body element we added
1370	testElement.innerHTML = "";
1371	testElementParent.removeChild( testElement );
1372
1373	// Technique from Juriy Zaytsev
1374	// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
1375	// We only care about the case where non-standard event systems
1376	// are used, namely in IE. Short-circuiting here helps us to
1377	// avoid an eval call (in setAttribute) which can cause CSP
1378	// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1379	if ( div.attachEvent ) {
1380		for( i in {
1381			submit: 1,
1382			change: 1,
1383			focusin: 1
1384		} ) {
1385			eventName = "on" + i;
1386			isSupported = ( eventName in div );
1387			if ( !isSupported ) {
1388				div.setAttribute( eventName, "return;" );
1389				isSupported = ( typeof div[ eventName ] === "function" );
1390			}
1391			support[ i + "Bubbles" ] = isSupported;
1392		}
1393	}
1394
1395	// Null connected elements to avoid leaks in IE
1396	testElement = fragment = select = opt = body = marginDiv = div = input = null;
1397
1398	return support;
1399})();
1400
1401// Keep track of boxModel
1402jQuery.boxModel = jQuery.support.boxModel;
1403
1404
1405
1406
1407var rbrace = /^(?:\{.*\}|\[.*\])$/,
1408	rmultiDash = /([a-z])([A-Z])/g;
1409
1410jQuery.extend({
1411	cache: {},
1412
1413	// Please use with caution
1414	uuid: 0,
1415
1416	// Unique for each copy of jQuery on the page
1417	// Non-digits removed to match rinlinejQuery
1418	expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1419
1420	// The following elements throw uncatchable exceptions if you
1421	// attempt to add expando properties to them.
1422	noData: {
1423		"embed": true,
1424		// Ban all objects except for Flash (which handle expandos)
1425		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1426		"applet": true
1427	},
1428
1429	hasData: function( elem ) {
1430		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1431
1432		return !!elem && !isEmptyDataObject( elem );
1433	},
1434
1435	data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1436		if ( !jQuery.acceptData( elem ) ) {
1437			return;
1438		}
1439
1440		var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,
1441
1442			// We have to handle DOM nodes and JS objects differently because IE6-7
1443			// can't GC object references properly across the DOM-JS boundary
1444			isNode = elem.nodeType,
1445
1446			// Only DOM nodes need the global jQuery cache; JS object data is
1447			// attached directly to the object so GC can occur automatically
1448			cache = isNode ? jQuery.cache : elem,
1449
1450			// Only defining an ID for JS objects if its cache already exists allows
1451			// the code to shortcut on the same path as a DOM node with no cache
1452			id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
1453
1454		// Avoid doing any more work than we need to when trying to get data on an
1455		// object that has no data at all
1456		if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
1457			return;
1458		}
1459
1460		if ( !id ) {
1461			// Only DOM nodes need a new unique ID for each element since their data
1462			// ends up in the global cache
1463			if ( isNode ) {
1464				elem[ jQuery.expando ] = id = ++jQuery.uuid;
1465
1466			} else {
1467				id = jQuery.expando;
1468			}
1469		}
1470
1471		if ( !cache[ id ] ) {
1472			cache[ id ] = {};
1473
1474			// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1475			// metadata on plain JS objects when the object is serialized using
1476			// JSON.stringify
1477			if ( !isNode ) {
1478				cache[ id ].toJSON = jQuery.noop;
1479			}
1480		}
1481

1482		// An object can be passed to jQuery.data instead of a key/value pair; this gets
1483		// shallow copied over onto the existing cache
1484		if ( typeof name === "object" || typeof name === "function" ) {
1485			if ( pvt ) {
1486				cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
1487			} else {
1488				cache[ id ] = jQuery.extend(cache[ id ], name);
1489			}
1490		}
1491
1492		thisCache = cache[ id ];
1493
1494		// Internal jQuery data is stored in a separate object inside the object's data
1495		// cache in order to avoid key collisions between internal data and user-defined
1496		// data
1497		if ( pvt ) {
1498			if ( !thisCache[ internalKey ] ) {
1499				thisCache[ internalKey ] = {};
1500			}
1501
1502			thisCache = thisCache[ internalKey ];
1503		}
1504
1505		if ( data !== undefined ) {
1506			thisCache[ jQuery.camelCase( name ) ] = data;
1507		}
1508
1509		// TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
1510		// not attempt to inspect the internal events object using jQuery.data, as this
1511		// internal data object is undocumented and subject to change.
1512		if ( name === "events" && !thisCache[name] ) {
1513			return thisCache[ internalKey ] && thisCache[ internalKey ].events;
1514		}
1515
1516		return getByName ? 
1517			// Check for both converted-to-camel and non-converted data property names
1518			thisCache[ jQuery.camelCase( name ) ] || thisCache[ name ] :
1519			thisCache;
1520	},
1521
1522	removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1523		if ( !jQuery.acceptData( elem ) ) {
1524			return;
1525		}
1526
1527		var internalKey = jQuery.expando, isNode = elem.nodeType,
1528
1529			// See jQuery.data for more information
1530			cache = isNode ? jQuery.cache : elem,
1531
1532			// See jQuery.data for more information
1533			id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
1534
1535		// If there is already no cache entry for this object, there is no
1536		// purpose in continuing
1537		if ( !cache[ id ] ) {
1538			return;
1539		}
1540
1541		if ( name ) {
1542			var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
1543
1544			if ( thisCache ) {
1545				delete thisCache[ name ];
1546
1547				// If there is no data left in the cache, we want to continue
1548				// and let the cache object itself get destroyed
1549				if ( !isEmptyDataObject(thisCache) ) {
1550					return;
1551				}
1552			}
1553		}
1554
1555		// See jQuery.data for more information
1556		if ( pvt ) {
1557			delete cache[ id ][ internalKey ];
1558
1559			// Don't destroy the parent cache unless the internal data object
1560			// had been the only thing left in it
1561			if ( !isEmptyDataObject(cache[ id ]) ) {
1562				return;
1563			}
1564		}
1565
1566		var internalCache = cache[ id ][ internalKey ];
1567
1568		// Browsers that fail expando deletion also refuse to delete expandos on
1569		// the window, but it will allow it on all other JS objects; other browsers
1570		// don't care
1571		if ( jQuery.support.deleteExpando || cache != window ) {
1572			delete cache[ id ];
1573		} else {
1574			cache[ id ] = null;
1575		}
1576
1577		// We destroyed the entire user cache at once because it's faster than
1578		// iterating through each key, but we need to continue to persist internal
1579		// data if it existed
1580		if ( internalCache ) {
1581			cache[ id ] = {};
1582			// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1583			// metadata on plain JS objects when the object is serialized using
1584			// JSON.stringify
1585			if ( !isNode ) {
1586				cache[ id ].toJSON = jQuery.noop;
1587			}
1588
1589			cache[ id ][ internalKey ] = internalCache;
1590
1591		// Otherwise, we need to eliminate the expando on the node to avoid
1592		// false lookups in the cache for entries that no longer exist
1593		} else if ( isNode ) {
1594			// IE does not allow us to delete expando properties from nodes,
1595			// nor does it have a removeAttribute function on Document nodes;
1596			// we must handle all of these cases
1597			if ( jQuery.support.deleteExpando ) {
1598				delete elem[ jQuery.expando ];
1599			} else if ( elem.removeAttribute ) {
1600				elem.removeAttribute( jQuery.expando );
1601			} else {
1602				elem[ jQuery.expando ] = null;
1603			}
1604		}
1605	},
1606
1607	// For internal use only.
1608	_data: function( elem, name, data ) {
1609		return jQuery.data( elem, name, data, true );
1610	},
1611
1612	// A method for determining if a DOM node can handle the data expando
1613	acceptData: function( elem ) {
1614		if ( elem.nodeName ) {
1615			var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1616
1617			if ( match ) {
1618				return !(match === true || elem.getAttribute("classid") !== match);
1619			}
1620		}
1621
1622		return true;
1623	}
1624});
1625
1626jQuery.fn.extend({
1627	data: function( key, value ) {
1628		var data = null;
1629
1630		if ( typeof key === "undefined" ) {
1631			if ( this.length ) {
1632				data = jQuery.data( this[0] );
1633
1634				if ( this[0].nodeType === 1 ) {
1635			    var attr = this[0].attributes, name;
1636					for ( var i = 0, l = attr.length; i < l; i++ ) {
1637						name = attr[i].name;
1638

1639						if ( name.indexOf( "data-" ) === 0 ) {
1640							name = jQuery.camelCase( name.substring(5) );
1641
1642							dataAttr( this[0], name, data[ name ] );
1643						}
1644					}
1645				}
1646			}
1647
1648			return data;
1649
1650		} else if ( typeof key === "object" ) {
1651			return this.each(function() {
1652				jQuery.data( this, key );
1653			});
1654		}
1655
1656		var parts = key.split(".");
1657		parts[1] = parts[1] ? "." + parts[1] : "";
1658
1659		if ( value === undefined ) {
1660			data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1661
1662			// Try to fetch any internally stored data first
1663			if ( data === undefined && this.length ) {
1664				data = jQuery.data( this[0], key );
1665				data = dataAttr( this[0], key, data );
1666			}
1667
1668			return data === undefined && parts[1] ?
1669				this.data( parts[0] ) :
1670				data;
1671
1672		} else {
1673			return this.each(function() {
1674				var $this = jQuery( this ),
1675					args = [ parts[0], value ];
1676
1677				$this.triggerHandler( "setData" + parts[1] + "!", args );
1678				jQuery.data( this, key, value );
1679				$this.triggerHandler( "changeData" + parts[1] + "!", args );
1680			});
1681		}
1682	},
1683
1684	removeData: function( key ) {
1685		return this.each(function() {
1686			jQuery.removeData( this, key );
1687		});
1688	}
1689});
1690
1691function dataAttr( elem, key, data ) {
1692	// If nothing was found internally, try to fetch any
1693	// data from the HTML5 data-* attribute
1694	if ( data === undefined && elem.nodeType === 1 ) {
1695		var name = "data-" + key.replace( rmultiDash, "$1-$2" ).toLowerCase();
1696
1697		data = elem.getAttribute( name );
1698
1699		if ( typeof data === "string" ) {
1700			try {
1701				data = data === "true" ? true :
1702				data === "false" ? false :
1703				data === "null" ? null :
1704				!jQuery.isNaN( data ) ? parseFloat( data ) :
1705					rbrace.test( data ) ? jQuery.parseJSON( data ) :
1706					data;
1707			} catch( e ) {}
1708
1709			// Make sure we set the data so it isn't changed later
1710			jQuery.data( elem, key, data );
1711
1712		} else {
1713			data = undefined;
1714		}
1715	}
1716
1717	return data;
1718}
1719
1720// TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
1721// property to be considered empty objects; this property always exists in
1722// order to make sure JSON.stringify does not expose internal metadata
1723function isEmptyDataObject( obj ) {
1724	for ( var name in obj ) {
1725		if ( name !== "toJSON" ) {
1726			return false;
1727		}
1728	}
1729
1730	return true;
1731}
1732
1733
1734
1735
1736function handleQueueMarkDefer( elem, type, src ) {
1737	var deferDataKey = type + "defer",
1738		queueDataKey = type + "queue",
1739		markDataKey = type + "mark",
1740		defer = jQuery.data( elem, deferDataKey, undefined, true );
1741	if ( defer &&
1742		( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
1743		( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
1744		// Give room for hard-coded callbacks to fire first
1745		// and eventually mark/queue something else on the element
1746		setTimeout( function() {
1747			if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
1748				!jQuery.data( elem, markDataKey, undefined, true ) ) {
1749				jQuery.removeData( elem, deferDataKey, true );
1750				defer.resolve();
1751			}
1752		}, 0 );
1753	}
1754}
1755
1756jQuery.extend({
1757
1758	_mark: function( elem, type ) {
1759		if ( elem ) {
1760			type = (type || "fx") + "mark";
1761			jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true );
1762		}
1763	},
1764
1765	_unmark: function( force, elem, type ) {
1766		if ( force !== true ) {
1767			type = elem;
1768			elem = force;
1769			force = false;
1770		}
1771		if ( elem ) {
1772			type = type || "fx";
1773			var key = type + "mark",
1774				count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) || 1 ) - 1 );
1775			if ( count ) {
1776				jQuery.data( elem, key, count, true );
1777			} else {
1778				jQuery.removeData( elem, key, true );
1779				handleQueueMarkDefer( elem, type, "mark" );
1780			}
1781		}
1782	},
1783
1784	queue: function( elem, type, data ) {
1785		if ( elem ) {
1786			type = (type || "fx") + "queue";
1787			var q = jQuery.data( elem, type, undefined, true );
1788			// Speed up dequeue by getting out quickly if this is just a lookup
1789			if ( data ) {
1790				if ( !q || jQuery.isArray(data) ) {
1791					q = jQuery.data( elem, type, jQuery.makeArray(data), true );
1792				} else {
1793					q.push( data );
1794				}
1795			}
1796			return q || [];
1797		}
1798	},
1799
1800	dequeue: function( elem, type ) {

1801		type = type || "fx";
1802
1803		var queue = jQuery.queue( elem, type ),
1804			fn = queue.shift(),
1805			defer;
1806
1807		// If the fx queue is dequeued, always remove the progress sentinel
1808		if ( fn === "inprogress" ) {
1809			fn = queue.shift();
1810		}
1811
1812		if ( fn ) {
1813			// Add a progress sentinel to prevent the fx queue from being
1814			// automatically dequeued
1815			if ( type === "fx" ) {
1816				queue.unshift("inprogress");
1817			}
1818
1819			fn.call(elem, function() {
1820				jQuery.dequeue(elem, type);
1821			});
1822		}
1823
1824		if ( !queue.length ) {
1825			jQuery.removeData( elem, type + "queue", true );
1826			handleQueueMarkDefer( elem, type, "queue" );
1827		}
1828	}
1829});
1830
1831jQuery.fn.extend({
1832	queue: function( type, data ) {
1833		if ( typeof type !== "string" ) {
1834			data = type;
1835			type = "fx";
1836		}
1837
1838		if ( data === undefined ) {
1839			return jQuery.queue( this[0], type );
1840		}
1841		return this.each(function() {
1842			var queue = jQuery.queue( this, type, data );
1843
1844			if ( type === "fx" && queue[0] !== "inprogress" ) {
1845				jQuery.dequeue( this, type );
1846			}
1847		});
1848	},
1849	dequeue: function( type ) {
1850		return this.each(function() {
1851			jQuery.dequeue( this, type );
1852		});
1853	},
1854	// Based off of the plugin by Clint Helfers, with permission.
1855	// http://blindsignals.com/index.php/2009/07/jquery-delay/
1856	delay: function( time, type ) {
1857		time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1858		type = type || "fx";
1859
1860		return this.queue( type, function() {
1861			var elem = this;
1862			setTimeout(function() {
1863				jQuery.dequeue( elem, type );
1864			}, time );
1865		});
1866	},
1867	clearQueue: function( type ) {
1868		return this.queue( type || "fx", [] );
1869	},
1870	// Get a promise resolved when queues of a certain type
1871	// are emptied (fx is the type by default)
1872	promise: function( type, object ) {
1873		if ( typeof type !== "string" ) {
1874			object = type;
1875			type = undefined;
1876		}
1877		type = type || "fx";
1878		var defer = jQuery.Deferred(),
1879			elements = this,
1880			i = elements.length,
1881			count = 1,
1882			deferDataKey = type + "defer",
1883			queueDataKey = type + "queue",
1884			markDataKey = type + "mark",
1885			tmp;
1886		function resolve() {
1887			if ( !( --count ) ) {
1888				defer.resolveWith( elements, [ elements ] );
1889			}
1890		}
1891		while( i-- ) {
1892			if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
1893					( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
1894						jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
1895					jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) {
1896				count++;
1897				tmp.done( resolve );
1898			}
1899		}
1900		resolve();
1901		return defer.promise();
1902	}
1903});
1904
1905
1906
1907
1908var rclass = /[\n\t\r]/g,
1909	rspace = /\s+/,
1910	rreturn = /\r/g,
1911	rtype = /^(?:button|input)$/i,
1912	rfocusable = /^(?:button|input|object|select|textarea)$/i,
1913	rclickable = /^a(?:rea)?$/i,
1914	rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
1915	rinvalidChar = /\:|^on/,
1916	formHook, boolHook;
1917
1918jQuery.fn.extend({
1919	attr: function( name, value ) {
1920		return jQuery.access( this, name, value, true, jQuery.attr );
1921	},
1922
1923	removeAttr: function( name ) {
1924		return this.each(function() {
1925			jQuery.removeAttr( this, name );
1926		});
1927	},
1928	
1929	prop: function( name, value ) {
1930		return jQuery.access( this, name, value, true, jQuery.prop );
1931	},
1932	
1933	removeProp: function( name ) {
1934		name = jQuery.propFix[ name ] || name;
1935		return this.each(function() {
1936			// try/catch handles cases where IE balks (such as removing a property on window)
1937			try {
1938				this[ name ] = undefined;
1939				delete this[ name ];
1940			} catch( e ) {}
1941		});
1942	},
1943
1944	addClass: function( value ) {
1945		var classNames, i, l, elem,
1946			setClass, c, cl;
1947
1948		if ( jQuery.isFunction( value ) ) {
1949			return this.each(function( j ) {
1950				jQuery( this ).addClass( value.call(this, j, this.className) );
1951			});
1952		}
1953
1954		if ( value && typeof value === "string" ) {
1955			classNames = value.split( rspace );
1956
1957			for ( i = 0, l = this.length; i < l; i++ ) {
1958				elem = this[ i ];
1959
1960				if ( elem.nodeType === 1 ) {
1961					if ( !elem.className && classNames.length === 1 ) {
1962						elem.className = value;
1963
1964					} else {
1965						setClass = " " + elem.className + " ";
1966
1967						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
1968							if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
1969								setClass += classNames[ c ] + " ";
1970							}
1971						}
1972						elem.className = jQuery.trim( setClass );
1973					}
1974				}
1975			}
1976		}
1977
1978		return this;
1979	},
1980
1981	removeClass: function( value ) {
1982		var classNames, i, l, elem, className, c, cl;
1983
1984		if ( jQuery.isFunction( value ) ) {
1985			return this.each(function( j ) {
1986				jQuery( this ).removeClass( value.call(this, j, this.className) );
1987			});
1988		}
1989
1990		if ( (value && typeof value === "string") || value === undefined ) {
1991			classNames = (value || "").split( rspace );
1992
1993			for ( i = 0, l = this.length; i < l; i++ ) {
1994				elem = this[ i ];
1995
1996				if ( elem.nodeType === 1 && elem.className ) {
1997					if ( value ) {
1998						className = (" " + elem.className + " ").replace( rclass, " " );
1999						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2000							className = className.replace(" " + classNames[ c ] + " ", " ");
2001						}
2002						elem.className = jQuery.trim( className );
2003
2004					} else {
2005						elem.className = "";
2006					}
2007				}
2008			}
2009		}
2010
2011		return this;
2012	},
2013
2014	toggleClass: function( value, stateVal ) {
2015		var type = typeof value,
2016			isBool = typeof stateVal === "boolean";
2017
2018		if ( jQuery.isFunction( value ) ) {
2019			return this.each(function( i ) {
2020				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
2021			});
2022		}
2023
2024		return this.each(function() {
2025			if ( type === "string" ) {
2026				// toggle individual class names
2027				var className,
2028					i = 0,
2029					self = jQuery( this ),
2030					state = stateVal,
2031					classNames = value.split( rspace );
2032
2033				while ( (className = classNames[ i++ ]) ) {
2034					// check each className given, space seperated list
2035					state = isBool ? state : !self.hasClass( className );
2036					self[ state ? "addClass" : "removeClass" ]( className );
2037				}
2038
2039			} else if ( type === "undefined" || type === "boolean" ) {
2040				if ( this.className ) {
2041					// store className if set
2042					jQuery._data( this, "__className__", this.className );
2043				}
2044
2045				// toggle whole className
2046				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2047			}
2048		});
2049	},
2050
2051	hasClass: function( selector ) {
2052		var className = " " + selector + " ";
2053		for ( var i = 0, l = this.length; i < l; i++ ) {
2054			if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2055				return true;
2056			}
2057		}
2058
2059		return false;
2060	},
2061
2062	val: function( value ) {
2063		var hooks, ret,
2064			elem = this[0];
2065		
2066		if ( !arguments.length ) {
2067			if ( elem ) {
2068				hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ];
2069
2070				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2071					return ret;
2072				}
2073
2074				ret = elem.value;
2075
2076				return typeof ret === "string" ? 
2077					// handle most common string cases
2078					ret.replace(rreturn, "") : 
2079					// handle cases where value is null/undef or number
2080					ret == null ? "" : ret;
2081			}
2082
2083			return undefined;
2084		}
2085
2086		var isFunction = jQuery.isFunction( value );
2087
2088		return this.each(function( i ) {
2089			var self = jQuery(this), val;
2090
2091			if ( this.nodeType !== 1 ) {
2092				return;
2093			}
2094
2095			if ( isFunction ) {
2096				val = value.call( this, i, self.val() );
2097			} else {
2098				val = value;
2099			}
2100
2101			// Treat null/undefined as "";

2101 convert numbers to string
2102			if ( val == null ) {
2103				val = "";
2104			} else if ( typeof val === "number" ) {
2105				val += "";
2106			} else if ( jQuery.isArray( val ) ) {
2107				val = jQuery.map(val, function ( value ) {
2108					return value == null ? "" : value + "";
2109				});
2110			}
2111
2112			hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ];
2113
2114			// If set returns undefined, fall back to normal setting
2115			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
2116				this.value = val;
2117			}
2118		});
2119	}
2120});
2121
2122jQuery.extend({
2123	valHooks: {
2124		option: {
2125			get: function( elem ) {
2126				// attributes.value is undefined in Blackberry 4.7 but
2127				// uses .value. See #6932
2128				var val = elem.attributes.value;
2129				return !val || val.specified ? elem.value : elem.text;
2130			}
2131		},
2132		select: {
2133			get: function( elem ) {
2134				var value,
2135					index = elem.selectedIndex,
2136					values = [],
2137					options = elem.options,
2138					one = elem.type === "select-one";
2139
2140				// Nothing was selected
2141				if ( index < 0 ) {
2142					return null;
2143				}
2144
2145				// Loop through all the selected options
2146				for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
2147					var option = options[ i ];
2148
2149					// Don't return options that are disabled or in a disabled optgroup
2150					if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2151							(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
2152
2153						// Get the specific value for the option
2154						value = jQuery( option ).val();
2155
2156						// We don't need an array for one selects
2157						if ( one ) {
2158							return value;
2159						}
2160
2161						// Multi-Selects return an array
2162						values.push( value );
2163					}
2164				}
2165
2166				// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2167				if ( one && !values.length && options.length ) {
2168					return jQuery( options[ index ] ).val();
2169				}
2170
2171				return values;
2172			},
2173
2174			set: function( elem, value ) {
2175				var values = jQuery.makeArray( value );
2176
2177				jQuery(elem).find("option").each(function() {
2178					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2179				});
2180
2181				if ( !values.length ) {
2182					elem.selectedIndex = -1;
2183				}
2184				return values;
2185			}
2186		}
2187	},
2188
2189	attrFn: {
2190		val: true,
2191		css: true,
2192		html: true,
2193		text: true,
2194		data: true,
2195		width: true,
2196		height: true,
2197		offset: true
2198	},
2199	
2200	attrFix: {
2201		// Always normalize to ensure hook usage
2202		tabindex: "tabIndex"
2203	},
2204	
2205	attr: function( elem, name, value, pass ) {
2206		var nType = elem.nodeType;
2207		
2208		// don't get/set attributes on text, comment and attribute nodes
2209		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2210			return undefined;
2211		}
2212
2213		if ( pass && name in jQuery.attrFn ) {
2214			return jQuery( elem )[ name ]( value );
2215		}
2216
2217		// Fallback to prop when attributes are not supported
2218		if ( !("getAttribute" in elem) ) {
2219			return jQuery.prop( elem, name, value );
2220		}
2221
2222		var ret, hooks,
2223			notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2224
2225		// Normalize the name if needed
2226		if ( notxml ) {
2227			name = jQuery.attrFix[ name ] || name;
2228
2229			hooks = jQuery.attrHooks[ name ];
2230
2231			if ( !hooks ) {
2232				// Use boolHook for boolean attributes
2233				if ( rboolean.test( name ) ) {
2234
2235					hooks = boolHook;
2236
2237				// Use formHook for forms and if the name contains certain characters
2238				} else if ( formHook && name !== "className" &&
2239					(jQuery.nodeName( elem, "form" ) || rinvalidChar.test( name )) ) {
2240
2241					hooks = formHook;
2242				}
2243			}
2244		}
2245
2246		if ( value !== undefined ) {
2247
2248			if ( value === null ) {
2249				jQuery.removeAttr( elem, name );
2250				return undefined;
2251
2252			} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2253				return ret;
2254
2255			} else {
2256				elem.setAttribute( name, "" + value );
2257				return value;
2258			}
2259
2260		} else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
2261			return ret;
2262
2263		} else {
2264
2265			ret = elem.getAttribute( name );
2266
2267			// Non-existent attributes return null, we normalize to undefined
2268			return ret === null ?
2269				undefined :
2270				ret;
2271		}
2272	},
2273
2274	removeAttr: function( elem, name ) {
2275		var propName;
2276		if ( elem.nodeType === 1 ) {
2277			name = jQuery.attrFix[ name ] || name;
2278		
2279			if ( jQuery.support.getSetAttribute ) {
2280				// Use removeAttribute in browsers that support it
2281				elem.removeAttribute( name );
2282			} else {
2283				jQuery.attr( elem, name, "" );
2284				elem.removeAttributeNode( elem.getAttributeNode( name ) );
2285			}
2286
2287			// Set corresponding property to false for boolean attributes
2288			if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] || name) in elem ) {
2289				elem[ propName ] = false;
2290			}
2291		}
2292	},
2293
2294	attrHooks: {

2295		type: {
2296			set: function( elem, value ) {
2297				// We can't allow the type property to be changed (since it causes problems in IE)
2298				if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
2299					jQuery.error( "type property can't be changed" );
2300				} else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2301					// Setting the type on a radio button after the value resets the value in IE6-9
2302					// Reset value to it's default in case type is set after value
2303					// This is for element creation
2304					var val = elem.value;
2305					elem.setAttribute( "type", value );
2306					if ( val ) {
2307						elem.value = val;
2308					}
2309					return value;
2310				}
2311			}
2312		},
2313		tabIndex: {
2314			get: function( elem ) {
2315				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2316				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2317				var attributeNode = elem.getAttributeNode("tabIndex");
2318
2319				return attributeNode && attributeNode.specified ?
2320					parseInt( attributeNode.value, 10 ) :
2321					rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
2322						0 :
2323						undefined;
2324			}
2325		},
2326		// Use the value property for back compat
2327		// Use the formHook for button elements in IE6/7 (#1954)
2328		value: {
2329			get: function( elem, name ) {
2330				if ( formHook && jQuery.nodeName( elem, "button" ) ) {
2331					return formHook.get( elem, name );
2332				}
2333				return name in elem ?
2334					elem.value :
2335					null;
2336			},
2337			set: function( elem, value, name ) {
2338				if ( formHook && jQuery.nodeName( elem, "button" ) ) {
2339					return formHook.set( elem, value, name );
2340				}
2341				// Does not return so that setAttribute is also used
2342				elem.value = value;
2343			}
2344		}
2345	},
2346
2347	propFix: {
2348		tabindex: "tabIndex",
2349		readonly: "readOnly",
2350		"for": "htmlFor",
2351		"class": "className",
2352		maxlength: "maxLength",
2353		cellspacing: "cellSpacing",
2354		cellpadding: "cellPadding",
2355		rowspan: "rowSpan",
2356		colspan: "colSpan",
2357		usemap: "useMap",
2358		frameborder: "frameBorder",
2359		contenteditable: "contentEditable"
2360	},
2361	
2362	prop: function( elem, name, value ) {
2363		var nType = elem.nodeType;
2364
2365		// don't get/set properties on text, comment and attribute nodes
2366		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2367			return undefined;
2368		}
2369
2370		var ret, hooks,
2371			notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2372
2373		if ( notxml ) {
2374			// Fix name and attach hooks
2375			name = jQuery.propFix[ name ] || name;
2376			hooks = jQuery.propHooks[ name ];
2377		}
2378
2379		if ( value !== undefined ) {
2380			if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2381				return ret;
2382
2383			} else {
2384				return (elem[ name ] = value);
2385			}
2386
2387		} else {
2388			if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== undefined ) {
2389				return ret;
2390
2391			} else {
2392				return elem[ name ];
2393			}
2394		}
2395	},
2396	
2397	propHooks: {}
2398});
2399
2400// Hook for boolean attributes
2401boolHook = {
2402	get: function( elem, name ) {
2403		// Align boolean attributes with corresponding properties
2404		return jQuery.prop( elem, name ) ?
2405			name.toLowerCase() :
2406			undefined;
2407	},
2408	set: function( elem, value, name ) {
2409		var propName;
2410		if ( value === false ) {
2411			// Remove boolean attributes when set to false
2412			jQuery.removeAttr( elem, name );
2413		} else {
2414			// value is true since we know at this point it's type boolean and not false
2415			// Set boolean attributes to the same name and set the DOM property
2416			propName = jQuery.propFix[ name ] || name;
2417			if ( propName in elem ) {
2418				// Only set the IDL specifically if it already exists on the element
2419				elem[ propName ] = true;
2420			}
2421
2422			elem.setAttribute( name, name.toLowerCase() );
2423		}
2424		return name;
2425	}
2426};
2427
2428// IE6/7 do not support getting/setting some attributes with get/setAttribute
2429if ( !jQuery.support.getSetAttribute ) {
2430
2431	// propFix is more comprehensive and contains all fixes
2432	jQuery.attrFix = jQuery.propFix;

2433	
2434	// Use this for any attribute on a form in IE6/7
2435	formHook = jQuery.attrHooks.name = jQuery.attrHooks.title = jQuery.valHooks.button = {
2436		get: function( elem, name ) {
2437			var ret;
2438			ret = elem.getAttributeNode( name );
2439			// Return undefined if nodeValue is empty string
2440			return ret && ret.nodeValue !== "" ?
2441				ret.nodeValue :
2442				undefined;
2443		},
2444		set: function( elem, value, name ) {
2445			// Check form objects in IE (multiple bugs related)
2446			// Only use nodeValue if the attribute node exists on the form
2447			var ret = elem.getAttributeNode( name );
2448			if ( ret ) {
2449				ret.nodeValue = value;
2450				return value;
2451			}
2452		}
2453	};
2454
2455	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
2456	// This is for removals
2457	jQuery.each([ "width", "height" ], function( i, name ) {
2458		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2459			set: function( elem, value ) {
2460				if ( value === "" ) {
2461					elem.setAttribute( name, "auto" );
2462					return value;
2463				}
2464			}
2465		});
2466	});
2467}
2468
2469
2470// Some attributes require a special call on IE
2471if ( !jQuery.support.hrefNormalized ) {
2472	jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
2473		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2474			get: function( elem ) {
2475				var ret = elem.getAttribute( name, 2 );
2476				return ret === null ? undefined : ret;
2477			}
2478		});
2479	});
2480}
2481
2482if ( !jQuery.support.style ) {
2483	jQuery.attrHooks.style = {
2484		get: function( elem ) {
2485			// Return undefined in the case of empty string
2486			// Normalize to lowercase since IE uppercases css property names
2487			return elem.style.cssText.toLowerCase() || undefined;
2488		},
2489		set: function( elem, value ) {
2490			return (elem.style.cssText = "" + value);
2491		}
2492	};
2493}
2494
2495// Safari mis-reports the default selected property of an option
2496// Accessing the parent's selectedIndex property fixes it
2497if ( !jQuery.support.optSelected ) {
2498	jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
2499		get: function( elem ) {
2500			var parent = elem.parentNode;
2501
2502			if ( parent ) {
2503				parent.selectedIndex;
2504
2505				// Make sure that it also works with optgroups, see #5701
2506				if ( parent.parentNode ) {
2507					parent.parentNode.selectedIndex;
2508				}
2509			}
2510		}
2511	});
2512}
2513
2514// Radios and checkboxes getter/setter
2515if ( !jQuery.support.checkOn ) {
2516	jQuery.each([ "radio", "checkbox" ], function() {
2517		jQuery.valHooks[ this ] = {
2518			get: function( elem ) {
2519				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2520				return elem.getAttribute("value") === null ? "on" : elem.value;
2521			}
2522		};
2523	});
2524}
2525jQuery.each([ "radio", "checkbox" ], function() {
2526	jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2527		set: function( elem, value ) {
2528			if ( jQuery.isArray( value ) ) {
2529				return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0);
2530			}
2531		}
2532	});
2533});
2534
2535
2536
2537
2538var rnamespaces = /\.(.*)$/,
2539	rformElems = /^(?:textarea|input|select)$/i,
2540	rperiod = /\./g,
2541	rspaces = / /g,
2542	rescape = /[^\w\s.|`]/g,
2543	fcleanup = function( nm ) {
2544		return nm.replace(rescape, "\\$&");
2545	};
2546
2547/*
2548 * A number of helper functions used for managing events.
2549 * Many of the ideas behind this code originated from
2550 * Dean Edwards' addEvent library.
2551 */
2552jQuery.event = {
2553
2554	// Bind an event to an element
2555	// Original by Dean Edwards
2556	add: function( elem, types, handler, data ) {
2557		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2558			return;
2559		}
2560
2561		if ( handler === false ) {
2562			handler = returnFalse;
2563		} else if ( !handler ) {
2564			// Fixes bug #7229. Fix recommended by jdalton
2565			return;
2566		}
2567
2568		var handleObjIn, handleObj;
2569
2570		if ( handler.handler ) {
2571			handleObjIn = handler;
2572			handler = handleObjIn.handler;
2573		}
2574
2575		// Make sure that the function being executed has a unique ID
2576		if ( !handler.guid ) {
2577			handler.guid = jQuery.guid++;
2578		}
2579
2580		// Init the element's event structure
2581		var elemData = jQuery._data( elem );
2582
2583		// If no elemData is found then we must be trying to bind to one of the
2584		// banned noData elements
2585		if ( !elemData ) {
2586			return;
2587		}
2588
2589		var events = elemData.events,
2590			eventHandle = elemData.handle;
2591
2592		if ( !events ) {
2593			elemData.events = events = {};
2594		}
2595
2596		if ( !eventHandle ) {
2597			elemData.handle = eventHandle = function( e ) {
2598				// Discard the second event of a jQuery.event.trigger() and
2599				// when an event is called after a page has unloaded
2600				return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
2601					jQuery.event.handle.apply( eventHandle.elem, arguments ) :
2602					undefined;
2603			};
2604		}
2605
2606		// Add elem as a property of the handle function
2607		// This is to prevent a memory leak with non-native events in IE.
2608		eventHandle.elem = elem;
2609
2610		// Handle multiple events separated by a space
2611		// jQuery(...).bind("mouseover mouseout", fn);
2612		types = types.split(" ");
2613
2614		var type, i = 0, namespaces;
2615
2616		while ( (type = types[ i++ ]) ) {
2617			handleObj = handleObjIn ?
2618				jQuery.extend({}, handleObjIn) :
2619				{ handler: handler, data: data };
2620
2621			// Namespaced event handlers
2622			if ( type.indexOf(".") > -1 ) {
2623				namespaces = type.split(".");
2624				type = namespaces.shift();
2625				handleObj.namespace = namespaces.slice(0).sort().join(".");
2626
2627			} else {
2628				namespaces = [];
2629				handleObj.namespace = "";
2630			}
2631
2632			handleObj.type = type;
2633			if ( !handleObj.guid ) {
2634				handleObj.guid = handler.guid;
2635			}
2636

2637			// Get the current list of functions bound to this event
2638			var handlers = events[ type ],
2639				special = jQuery.event.special[ type ] || {};
2640
2641			// Init the event handler queue
2642			if ( !handlers ) {
2643				handlers = events[ type ] = [];
2644
2645				// Check for a special event handler
2646				// Only use addEventListener/attachEvent if the special
2647				// events handler returns false
2648				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2649					// Bind the global event handler to the element
2650					if ( elem.addEventListener ) {
2651						elem.addEventListener( type, eventHandle, false );
2652
2653					} else if ( elem.attachEvent ) {
2654						elem.attachEvent( "on" + type, eventHandle );
2655					}
2656				}
2657			}
2658
2659			if ( special.add ) {
2660				special.add.call( elem, handleObj );
2661
2662				if ( !handleObj.handler.guid ) {
2663					handleObj.handler.guid = handler.guid;
2664				}
2665			}
2666
2667			// Add the function to the element's handler list
2668			handlers.push( handleObj );
2669
2670			// Keep track of which events have been used, for event optimization
2671			jQuery.event.global[ type ] = true;
2672		}
2673
2674		// Nullify elem to prevent memory leaks in IE
2675		elem = null;
2676	},
2677
2678	global: {},
2679
2680	// Detach an event or set of events from an element
2681	remove: function( elem, types, handler, pos ) {
2682		// don't do events on text and comment nodes
2683		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2684			return;
2685		}
2686
2687		if ( handler === false ) {
2688			handler = returnFalse;
2689		}
2690
2691		var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
2692			elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
2693			events = elemData && elemData.events;
2694
2695		if ( !elemData || !events ) {
2696			return;
2697		}
2698
2699		// types is actually an event object here
2700		if ( types && types.type ) {
2701			handler = types.handler;
2702			types = types.type;
2703		}
2704
2705		// Unbind all events for the element
2706		if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
2707			types = types || "";
2708
2709			for ( type in events ) {
2710				jQuery.event.remove( elem, type + types );
2711			}
2712
2713			return;
2714		}
2715
2716		// Handle multiple events separated by a space
2717		// jQuery(...).unbind("mouseover mouseout", fn);
2718		types = types.split(" ");
2719
2720		while ( (type = types[ i++ ]) ) {
2721			origType = type;
2722			handleObj = null;
2723			all = type.indexOf(".") < 0;
2724			namespaces = [];
2725
2726			if ( !all ) {
2727				// Namespaced event handlers
2728				namespaces = type.split(".");
2729				type = namespaces.shift();
2730
2731				namespace = new RegExp("(^|\\.)" +
2732					jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
2733			}
2734
2735			eventType = events[ type ];
2736
2737			if ( !eventType ) {
2738				continue;
2739			}
2740
2741			if ( !handler ) {
2742				for ( j = 0; j < eventType.length; j++ ) {
2743					handleObj = eventType[ j ];
2744
2745					if ( all || namespace.test( handleObj.namespace ) ) {
2746						jQuery.event.remove( elem, origType, handleObj.handler, j );
2747						eventType.splice( j--, 1 );
2748					}
2749				}
2750
2751				continue;
2752			}
2753
2754			special = jQuery.event.special[ type ] || {};
2755
2756			for ( j = pos || 0; j < eventType.length; j++ ) {
2757				handleObj = eventType[ j ];
2758
2759				if ( handler.guid === handleObj.guid ) {
2760					// remove the given handler for the given type
2761					if ( all || namespace.test( handleObj.namespace ) ) {
2762						if ( pos == null ) {
2763							eventType.splice( j--, 1 );
2764						}
2765
2766						if ( special.remove ) {
2767							special.remove.call( elem, handleObj );
2768						}
2769					}
2770
2771					if ( pos != null ) {
2772						break;
2773					}
2774				}
2775			}
2776
2777			// remove generic event handler if no more handlers exist
2778			if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
2779				if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
2780					jQuery.removeEvent( elem, type, elemData.handle );
2781				}
2782
2783				ret = null;
2784				delete events[ type ];
2785			}
2786		}
2787
2788		// Remove the expando if it's no longer used
2789		if ( jQuery.isEmptyObject( events ) ) {
2790			var handle = elemData.handle;
2791			if ( handle ) {
2792				handle.elem = null;
2793			}
2794
2795			delete elemData.events;
2796			delete elemData.handle;
2797
2798			if ( jQuery.isEmptyObject( elemData ) ) {
2799				jQuery.removeData( elem, undefined, true );
2800			}
2801		}
2802	},
2803	
2804	// Events that are safe to short-circuit if no handlers are attached.
2805	// Native DOM events should not be added, they may have inline handlers.
2806	customEvent: {
2807		"getData": true,
2808		"setData": true,
2809		"changeData": true
2810	},
2811
2812	trigger: function( event, data, elem, onlyHandlers ) {
2813		// Event object or event type
2814		var type = event.type || event,
2815			namespaces = [],
2816			exclusive;
2817
2818		if ( type.indexOf("!") >= 0 ) {
2819			// Exclusive events trigger only for the exact event (no namespaces)
2820			type = type.slice(0, -1);
2821			exclusive = true;
2822		}
2823
2824		if ( type.indexOf(".") >= 0 ) {
2825			// Namespaced trigger; create a regexp to match event type in handle()
2826			namespaces = type.split(".");
2827			type = namespaces.shift();
2828			namespaces.sort();
2829		}
2830
2831		if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
2832			// No jQuery handlers for this event type, and it can't have inline handlers
2833			return;
2834		}
2835
2836		// Caller can pass in an Event, Object, or just an event type string
2837		event = typeof event === "object" ?
2838			// jQuery.Event object
2839			event[ jQuery.expando ] ? event :
2840			// Object literal
2841			new jQuery.Event( type, event ) :
2842			// Just the event type (string)
2843			new jQuery.Event( type );
2844
2845		event.type = type;
2846		event.exclusive = exclusive;
2847		event.namespace = namespaces.join(".");
2848		event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)");
2849		
2850		// triggerHandler() and global events don't bubble or run the default action
2851		if ( onlyHandlers || !elem ) {
2852			event.preventDefault();
2853			event.stopPropagation();
2854		}
2855
2856		// Handle a global trigger
2857		if ( !elem ) {
2858			// TODO: Stop taunting the data cache; remove global events and always attach to document
2859			jQuery.each( jQuery.cache, function() {
2860				// internalKey variable is just used to make it easier to find
2861				// and potentially change this stuff later; currently it just
2862				// points to jQuery.expando
2863				var internalKey = jQuery.expando,
2864					internalCache = this[ internalKey ];
2865				if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
2866					jQuery.event.trigger( event, data, internalCache.handle.elem );
2867				}
2868			});
2869			return;
2870		}
2871
2872		// Don't do events on text and comment nodes
2873		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2874			return;
2875		}
2876
2877		// Clean up the event in case it is being reused
2878		event.result = undefined;
2879		event.target = elem;
2880
2881		// Clone any incoming data and prepend the event, creating the handler arg list
2882		data = data != null ? jQuery.makeArray( data ) : [];
2883		data.unshift( event );
2884
2885		var cur = elem,