https://www.helictit.info/sites/default/files/advagg_js/js__czUetr…jc6Le8qq6mHSjnrYVeVaYBSWTz_ji3Wh0YZB8yYE.js

1/*!
2 * jQuery JavaScript Library v1.5.1
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 Feb 23 13:55:29 2011 -0500
15 */
16(function( window, undefined ) {
17
18// Use the correct document accordingly with window argument (sandbox)
19var document = window.document;
20var jQuery = (function() {
21
22// Define a local copy of jQuery
23var jQuery = function( selector, context ) {
24		// The jQuery object is actually just the init constructor 'enhanced'
25		return new jQuery.fn.init( selector, context, rootjQuery );
26	},
27
28	// Map over jQuery in case of overwrite
29	_jQuery = window.jQuery,
30
31	// Map over the $ in case of overwrite
32	_$ = window.$,
33
34	// A central reference to the root jQuery(document)
35	rootjQuery,
36
37	// A simple way to check for HTML strings or ID strings
38	// (both of which we optimize for)
39	quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/,
40
41	// Check if a string has a non-whitespace character in it
42	rnotwhite = /\S/,
43
44	// Used for trimming whitespace
45	trimLeft = /^\s+/,
46	trimRight = /\s+$/,
47
48	// Check for digits
49	rdigit = /\d/,
50
51	// Match a standalone tag
52	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
53
54	// JSON RegExp
55	rvalidchars = /^[\],:{}\s]*$/,
56	rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
57	rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
58	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
59
60	// Useragent RegExp
61	rwebkit = /(webkit)[ \/]([\w.]+)/,
62	ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
63	rmsie = /(msie) ([\w.]+)/,
64	rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
65
66	// Keep a UserAgent string for use with jQuery.browser
67	userAgent = navigator.userAgent,
68
69	// For matching the engine and version of the browser
70	browserMatch,
71
72	// Has the ready events already been bound?
73	readyBound = false,
74
75	// The deferred used on DOM ready
76	readyList,
77
78	// Promise methods
79	promiseMethods = "then done fail isResolved isRejected promise".split( " " ),
80
81	// The ready event handler
82	DOMContentLoaded,
83
84	// Save a reference to some core methods
85	toString = Object.prototype.toString,
86	hasOwn = Object.prototype.hasOwnProperty,
87	push = Array.prototype.push,
88	slice = Array.prototype.slice,
89	trim = String.prototype.trim,
90	indexOf = Array.prototype.indexOf,
91
92	// [[Class]] -> type pairs
93	class2type = {};
94
95jQuery.fn = jQuery.prototype = {
96	constructor: jQuery,
97	init: function( selector, context, rootjQuery ) {
98		var match, elem, ret, doc;
99
100		// Handle $(""), $(null), or $(undefined)
101		if ( !selector ) {
102			return this;
103		}
104
105		// Handle $(DOMElement)
106		if ( selector.nodeType ) {
107			this.context = this[0] = selector;
108			this.length = 1;
109			return this;
110		}
111
112		// The body element only exists once, optimize finding it
113		if ( selector === "body" && !context && document.body ) {
114			this.context = document;
115			this[0] = document.body;
116			this.selector = "body";
117			this.length = 1;
118			return this;
119		}
120
121		// Handle HTML strings
122		if ( typeof selector === "string" ) {
123			// Are we dealing with HTML string or an ID?
124			match = quickExpr.exec( selector );
125
126			// Verify a match, and that no context was specified for #id
127			if ( match && (match[1] || !context) ) {
128
129				// HANDLE: $(html) -> $(array)
130				if ( match[1] ) {
131					context = context instanceof jQuery ? context[0] : context;
132					doc = (context ? context.ownerDocument || context : document);
133
134					// If a single string is passed in and it's a single tag
135					// just do a createElement and skip the rest
136					ret = rsingleTag.exec( selector );
137
138					if ( ret ) {
139						if ( jQuery.isPlainObject( context ) ) {
140							selector = [ document.createElement( ret[1] ) ];
141							jQuery.fn.attr.call( selector, context, true );
142
143						} else {
144							selector = [ doc.createElement( ret[1] ) ];
145						}
146
147					} else {
148						ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
149						selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
150					}
151
152					return jQuery.merge( this, selector );
153
154				// HANDLE: $("#id")
155				} else {
156					elem = document.getElementById( match[2] );
157
158					// Check parentNode to catch when Blackberry 4.6 returns
159					// nodes that are no longer in the document #6963
160					if ( elem && elem.parentNode ) {
161						// Handle the case where IE and Opera return items
162						// by name instead of ID
163						if ( elem.id !== match[2] ) {
164							return rootjQuery.find( selector );
165						}
166
167						// Otherwise, we inject the element directly into the jQuery object
168						this.length = 1;
169						this[0] = elem;
170					}
171
172					this.context = document;
173					this.selector = selector;
174					return this;
175				}
176
177			// HANDLE: $(expr, $(...))
178			} else if ( !context || context.jquery ) {
179				return (context || rootjQuery).find( selector );
180
181			// HANDLE: $(expr, context)
182			// (which is just equivalent to: $(context).find(expr)
183			} else {
184				return this.constructor( context ).find( selector );
185			}
186
187		// HANDLE: $(function)
188		// Shortcut for document ready
189		} else if ( jQuery.isFunction( selector ) ) {
190			return rootjQuery.ready( selector );
191		}
192
193		if (selector.selector !== undefined) {
194			this.selector = selector.selector;
195			this.context = selector.context;
196		}
197
198		return jQuery.makeArray( selector, this );
199	},
200
201	// Start with an empty selector
202	selector: "",
203
204	// The current version of jQuery being used

205	jquery: "1.5.1",
206
207	// The default length of a jQuery object is 0
208	length: 0,
209
210	// The number of elements contained in the matched element set
211	size: function() {
212		return this.length;
213	},
214
215	toArray: function() {
216		return slice.call( this, 0 );
217	},
218
219	// Get the Nth element in the matched element set OR
220	// Get the whole matched element set as a clean array
221	get: function( num ) {
222		return num == null ?
223
224			// Return a 'clean' array
225			this.toArray() :
226
227			// Return just the object
228			( num < 0 ? this[ this.length + num ] : this[ num ] );
229	},
230
231	// Take an array of elements and push it onto the stack
232	// (returning the new matched element set)
233	pushStack: function( elems, name, selector ) {
234		// Build a new jQuery matched element set
235		var ret = this.constructor();
236
237		if ( jQuery.isArray( elems ) ) {
238			push.apply( ret, elems );
239
240		} else {
241			jQuery.merge( ret, elems );
242		}
243
244		// Add the old object onto the stack (as a reference)
245		ret.prevObject = this;
246
247		ret.context = this.context;
248
249		if ( name === "find" ) {
250			ret.selector = this.selector + (this.selector ? " " : "") + selector;
251		} else if ( name ) {
252			ret.selector = this.selector + "." + name + "(" + selector + ")";
253		}
254
255		// Return the newly-formed element set
256		return ret;
257	},
258
259	// Execute a callback for every element in the matched set.
260	// (You can seed the arguments with an array of args, but this is
261	// only used internally.)
262	each: function( callback, args ) {
263		return jQuery.each( this, callback, args );
264	},
265
266	ready: function( fn ) {
267		// Attach the listeners
268		jQuery.bindReady();
269
270		// Add the callback
271		readyList.done( fn );
272
273		return this;
274	},
275
276	eq: function( i ) {
277		return i === -1 ?
278			this.slice( i ) :
279			this.slice( i, +i + 1 );
280	},
281
282	first: function() {
283		return this.eq( 0 );
284	},
285
286	last: function() {
287		return this.eq( -1 );
288	},
289
290	slice: function() {
291		return this.pushStack( slice.apply( this, arguments ),
292			"slice", slice.call(arguments).join(",") );
293	},
294
295	map: function( callback ) {
296		return this.pushStack( jQuery.map(this, function( elem, i ) {
297			return callback.call( elem, i, elem );
298		}));
299	},
300
301	end: function() {
302		return this.prevObject || this.constructor(null);
303	},
304
305	// For internal use only.
306	// Behaves like an Array's method, not like a jQuery method.
307	push: push,
308	sort: [].sort,
309	splice: [].splice
310};
311
312// Give the init function the jQuery prototype for later instantiation
313jQuery.fn.init.prototype = jQuery.fn;
314
315jQuery.extend = jQuery.fn.extend = function() {
316	var options, name, src, copy, copyIsArray, clone,
317		target = arguments[0] || {},
318		i = 1,
319		length = arguments.length,
320		deep = false;
321
322	// Handle a deep copy situation
323	if ( typeof target === "boolean" ) {
324		deep = target;
325		target = arguments[1] || {};
326		// skip the boolean and the target
327		i = 2;
328	}
329
330	// Handle case when target is a string or something (possible in deep copy)
331	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
332		target = {};
333	}
334
335	// extend jQuery itself if only one argument is passed
336	if ( length === i ) {
337		target = this;
338		--i;
339	}
340
341	for ( ; i < length; i++ ) {
342		// Only deal with non-null/undefined values
343		if ( (options = arguments[ i ]) != null ) {
344			// Extend the base object
345			for ( name in options ) {
346				src = target[ name ];
347				copy = options[ name ];
348
349				// Prevent never-ending loop
350				if ( target === copy ) {
351					continue;
352				}
353
354				// Recurse if we're merging plain objects or arrays
355				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
356					if ( copyIsArray ) {
357						copyIsArray = false;
358						clone = src && jQuery.isArray(src) ? src : [];
359
360					} else {
361						clone = src && jQuery.isPlainObject(src) ? src : {};
362					}
363
364					// Never move original objects, clone them
365					target[ name ] = jQuery.extend( deep, clone, copy );
366
367				// Don't bring in undefined values
368				} else if ( copy !== undefined ) {
369					target[ name ] = copy;
370				}
371			}
372		}
373	}
374
375	// Return the modified object
376	return target;
377};
378
379jQuery.extend({
380	noConflict: function( deep ) {
381		window.$ = _$;
382
383		if ( deep ) {
384			window.jQuery = _jQuery;
385		}
386
387		return jQuery;
388	},
389
390	// Is the DOM ready to be used? Set to true once it occurs.
391	isReady: false,
392
393	// A counter to track how many items to wait for before
394	// the ready event fires. See #6781
395	readyWait: 1,
396
397	// Handle when the DOM is ready
398	ready: function( wait ) {
399		// A third-party is pushing the ready event forwards
400		if ( wait === true ) {
401			jQuery.readyWait--;
402		}
403
404		// Make sure that the DOM is not already loaded
405		if ( !jQuery.readyWait || (wait !== true && !jQuery.isReady) ) {
406			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
407			if ( !document.body ) {
408				return setTimeout( jQuery.ready, 1 );
409			}
410
411			// Remember that the DOM is ready
412			jQuery.isReady = true;
413
414			// If a normal DOM Ready event fired, decrement, and wait if need be
415			if ( wait !== true && --jQuery.readyWait > 0 ) {
416				return;
417			}
418

419			// If there are functions bound, to execute
420			readyList.resolveWith( document, [ jQuery ] );
421
422			// Trigger any bound ready events
423			if ( jQuery.fn.trigger ) {
424				jQuery( document ).trigger( "ready" ).unbind( "ready" );
425			}
426		}
427	},
428
429	bindReady: function() {
430		if ( readyBound ) {
431			return;
432		}
433
434		readyBound = true;
435
436		// Catch cases where $(document).ready() is called after the
437		// browser event has already occurred.
438		if ( document.readyState === "complete" ) {
439			// Handle it asynchronously to allow scripts the opportunity to delay ready
440			return setTimeout( jQuery.ready, 1 );
441		}
442
443		// Mozilla, Opera and webkit nightlies currently support this event
444		if ( document.addEventListener ) {
445			// Use the handy event callback
446			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
447
448			// A fallback to window.onload, that will always work
449			window.addEventListener( "load", jQuery.ready, false );
450
451		// If IE event model is used
452		} else if ( document.attachEvent ) {
453			// ensure firing before onload,
454			// maybe late but safe also for iframes
455			document.attachEvent("onreadystatechange", DOMContentLoaded);
456
457			// A fallback to window.onload, that will always work
458			window.attachEvent( "onload", jQuery.ready );
459
460			// If IE and not a frame
461			// continually check to see if the document is ready
462			var toplevel = false;
463
464			try {
465				toplevel = window.frameElement == null;
466			} catch(e) {}
467
468			if ( document.documentElement.doScroll && toplevel ) {
469				doScrollCheck();
470			}
471		}
472	},
473
474	// See test/unit/core.js for details concerning isFunction.
475	// Since version 1.3, DOM methods and functions like alert
476	// aren't supported. They return false on IE (#2968).
477	isFunction: function( obj ) {
478		return jQuery.type(obj) === "function";
479	},
480
481	isArray: Array.isArray || function( obj ) {
482		return jQuery.type(obj) === "array";
483	},
484
485	// A crude way of determining if an object is a window
486	isWindow: function( obj ) {
487		return obj && typeof obj === "object" && "setInterval" in obj;
488	},
489
490	isNaN: function( obj ) {
491		return obj == null || !rdigit.test( obj ) || isNaN( obj );
492	},
493
494	type: function( obj ) {
495		return obj == null ?
496			String( obj ) :
497			class2type[ toString.call(obj) ] || "object";
498	},
499
500	isPlainObject: function( obj ) {
501		// Must be an Object.
502		// Because of IE, we also have to check the presence of the constructor property.
503		// Make sure that DOM nodes and window objects don't pass through, as well
504		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
505			return false;
506		}
507
508		// Not own constructor property must be Object
509		if ( obj.constructor &&
510			!hasOwn.call(obj, "constructor") &&
511			!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
512			return false;
513		}
514
515		// Own properties are enumerated firstly, so to speed up,
516		// if last one is own, then all properties are own.
517
518		var key;
519		for ( key in obj ) {}
520
521		return key === undefined || hasOwn.call( obj, key );
522	},
523
524	isEmptyObject: function( obj ) {
525		for ( var name in obj ) {
526			return false;
527		}
528		return true;
529	},
530
531	error: function( msg ) {
532		throw msg;
533	},
534
535	parseJSON: function( data ) {
536		if ( typeof data !== "string" || !data ) {
537			return null;
538		}
539
540		// Make sure leading/trailing whitespace is removed (IE can't handle it)
541		data = jQuery.trim( data );
542
543		// Make sure the incoming data is actual JSON
544		// Logic borrowed from http://json.org/json2.js
545		if ( rvalidchars.test(data.replace(rvalidescape, "@")
546			.replace(rvalidtokens, "]")
547			.replace(rvalidbraces, "")) ) {
548
549			// Try to use the native JSON parser first
550			return window.JSON && window.JSON.parse ?
551				window.JSON.parse( data ) :
552				(new Function("return " + data))();
553
554		} else {
555			jQuery.error( "Invalid JSON: " + data );
556		}
557	},
558
559	// Cross-browser xml parsing
560	// (xml & tmp used internally)
561	parseXML: function( data , xml , tmp ) {
562
563		if ( window.DOMParser ) { // Standard
564			tmp = new DOMParser();
565			xml = tmp.parseFromString( data , "text/xml" );
566		} else { // IE
567			xml = new ActiveXObject( "Microsoft.XMLDOM" );
568			xml.async = "false";
569			xml.loadXML( data );
570		}
571
572		tmp = xml.documentElement;
573
574		if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
575			jQuery.error( "Invalid XML: " + data );
576		}
577
578		return xml;
579	},
580
581	noop: function() {},
582
583	// Evalulates a script in a global context
584	globalEval: function( data ) {
585		if ( data && rnotwhite.test(data) ) {
586			// Inspired by code by Andrea Giammarchi
587			// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
588			var head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement,
589				script = document.createElement( "script" );
590
591			if ( jQuery.support.scriptEval() ) {
592				script.appendChild( document.createTextNode( data ) );
593			} else {
594				script.text = data;
595			}
596
597			// Use insertBefore instead of appendChild to circumvent an IE6 bug.
598			// This arises when a base node is used (#2709).

599			head.insertBefore( script, head.firstChild );
600			head.removeChild( script );
601		}
602	},
603
604	nodeName: function( elem, name ) {
605		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
606	},
607
608	// args is for internal usage only
609	each: function( object, callback, args ) {
610		var name, i = 0,
611			length = object.length,
612			isObj = length === undefined || jQuery.isFunction(object);
613
614		if ( args ) {
615			if ( isObj ) {
616				for ( name in object ) {
617					if ( callback.apply( object[ name ], args ) === false ) {
618						break;
619					}
620				}
621			} else {
622				for ( ; i < length; ) {
623					if ( callback.apply( object[ i++ ], args ) === false ) {
624						break;
625					}
626				}
627			}
628
629		// A special, fast, case for the most common use of each
630		} else {
631			if ( isObj ) {
632				for ( name in object ) {
633					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
634						break;
635					}
636				}
637			} else {
638				for ( var value = object[0];
639					i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
640			}
641		}
642
643		return object;
644	},
645
646	// Use native String.trim function wherever possible
647	trim: trim ?
648		function( text ) {
649			return text == null ?
650				"" :
651				trim.call( text );
652		} :
653
654		// Otherwise use our own trimming functionality
655		function( text ) {
656			return text == null ?
657				"" :
658				text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
659		},
660
661	// results is for internal usage only
662	makeArray: function( array, results ) {
663		var ret = results || [];
664
665		if ( array != null ) {
666			// The window, strings (and functions) also have 'length'
667			// The extra typeof function check is to prevent crashes
668			// in Safari 2 (See: #3039)
669			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
670			var type = jQuery.type(array);
671
672			if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
673				push.call( ret, array );
674			} else {
675				jQuery.merge( ret, array );
676			}
677		}
678
679		return ret;
680	},
681
682	inArray: function( elem, array ) {
683		if ( array.indexOf ) {
684			return array.indexOf( elem );
685		}
686
687		for ( var i = 0, length = array.length; i < length; i++ ) {
688			if ( array[ i ] === elem ) {
689				return i;
690			}
691		}
692
693		return -1;
694	},
695
696	merge: function( first, second ) {
697		var i = first.length,
698			j = 0;
699
700		if ( typeof second.length === "number" ) {
701			for ( var l = second.length; j < l; j++ ) {
702				first[ i++ ] = second[ j ];
703			}
704
705		} else {
706			while ( second[j] !== undefined ) {
707				first[ i++ ] = second[ j++ ];
708			}
709		}
710
711		first.length = i;
712
713		return first;
714	},
715
716	grep: function( elems, callback, inv ) {
717		var ret = [], retVal;
718		inv = !!inv;
719
720		// Go through the array, only saving the items
721		// that pass the validator function
722		for ( var i = 0, length = elems.length; i < length; i++ ) {
723			retVal = !!callback( elems[ i ], i );
724			if ( inv !== retVal ) {
725				ret.push( elems[ i ] );
726			}
727		}
728
729		return ret;
730	},
731
732	// arg is for internal usage only
733	map: function( elems, callback, arg ) {
734		var ret = [], value;
735
736		// Go through the array, translating each of the items to their
737		// new value (or values).
738		for ( var i = 0, length = elems.length; i < length; i++ ) {
739			value = callback( elems[ i ], i, arg );
740
741			if ( value != null ) {
742				ret[ ret.length ] = value;
743			}
744		}
745
746		// Flatten any nested arrays
747		return ret.concat.apply( [], ret );
748	},
749
750	// A global GUID counter for objects
751	guid: 1,
752
753	proxy: function( fn, proxy, thisObject ) {
754		if ( arguments.length === 2 ) {
755			if ( typeof proxy === "string" ) {
756				thisObject = fn;
757				fn = thisObject[ proxy ];
758				proxy = undefined;
759
760			} else if ( proxy && !jQuery.isFunction( proxy ) ) {
761				thisObject = proxy;
762				proxy = undefined;
763			}
764		}
765
766		if ( !proxy && fn ) {
767			proxy = function() {
768				return fn.apply( thisObject || this, arguments );
769			};
770		}
771
772		// Set the guid of unique handler to the same of original handler, so it can be removed
773		if ( fn ) {
774			proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
775		}
776
777		// So proxy can be declared as an argument
778		return proxy;
779	},
780
781	// Mutifunctional method to get and set values to a collection
782	// The value/s can be optionally by executed if its a function
783	access: function( elems, key, value, exec, fn, pass ) {
784		var length = elems.length;
785
786		// Setting many attributes
787		if ( typeof key === "object" ) {
788			for ( var k in key ) {
789				jQuery.access( elems, k, key[k], exec, fn, value );
790			}
791			return elems;
792		}
793
794		// Setting one attribute
795		if ( value !== undefined ) {
796			// Optionally, function values get executed if exec is true
797			exec = !pass && exec && jQuery.isFunction(value);
798
799			for ( var i = 0; i < length; i++ ) {
800				fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
801			}
802
803			return elems;
804		}
805
806		// Getting an attribute
807		return length ? fn( elems[0], key ) : undefined;
808	},
809
810	now: function() {
811		return (new Date()).getTime();
812	},
813
814	// Create a simple deferred (one callbacks list)
815	_Deferred: function() {
816		var // callbacks list
817			callbacks = [],
818			// stored [ context , args ]
819			fired,
820			// to avoid firing when already doing so
821			firing,
822			// flag to know if the deferred has been cancelled
823			cancelled,
824			// the deferred itself
825			deferred  = {
826
827				// done( f1, f2, ...)
828				done: function() {
829					if ( !cancelled ) {
830						var args = arguments,
831							i,
832							length,
833							elem,
834							type,
835							_fired;
836						if ( fired ) {
837							_fired = fired;
838							fired = 0;
839						}
840						for ( i = 0, length = args.length; i < length; i++ ) {
841							elem = args[ i ];
842							type = jQuery.type( elem );
843							if ( type === "array" ) {
844								deferred.done.apply( deferred, elem );
845							} else if ( type === "function" ) {
846								callbacks.push( elem );
847							}
848						}
849						if ( _fired ) {
850							deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
851						}
852					}
853					return this;
854				},
855
856				// resolve with given context and args
857				resolveWith: function( context, args ) {
858					if ( !cancelled && !fired && !firing ) {
859						firing = 1;
860						try {
861							while( callbacks[ 0 ] ) {
862								callbacks.shift().apply( context, args );
863							}
864						}
865						// We have to add a catch block for
866						// IE prior to 8 or else the finally
867						// block will never get executed
868						catch (e) {
869							throw e;
870						}
871						finally {
872							fired = [ context, args ];
873							firing = 0;
874						}
875					}
876					return this;
877				},
878
879				// resolve with this as context and given arguments
880				resolve: function() {
881					deferred.resolveWith( jQuery.isFunction( this.promise ) ? this.promise() : this, arguments );
882					return this;
883				},
884
885				// Has this deferred been resolved?
886				isResolved: function() {
887					return !!( firing || fired );
888				},
889
890				// Cancel
891				cancel: function() {
892					cancelled = 1;
893					callbacks = [];
894					return this;
895				}
896			};
897
898		return deferred;
899	},
900
901	// Full fledged deferred (two callbacks list)
902	Deferred: function( func ) {
903		var deferred = jQuery._Deferred(),
904			failDeferred = jQuery._Deferred(),
905			promise;
906		// Add errorDeferred methods, then and promise
907		jQuery.extend( deferred, {
908			then: function( doneCallbacks, failCallbacks ) {
909				deferred.done( doneCallbacks ).fail( failCallbacks );
910				return this;
911			},
912			fail: failDeferred.done,
913			rejectWith: failDeferred.resolveWith,
914			reject: failDeferred.resolve,
915			isRejected: failDeferred.isResolved,
916			// Get a promise for this deferred
917			// If obj is provided, the promise aspect is added to the object
918			promise: function( obj ) {
919				if ( obj == null ) {
920					if ( promise ) {
921						return promise;
922					}
923					promise = obj = {};
924				}
925				var i = promiseMethods.length;
926				while( i-- ) {
927					obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
928				}
929				return obj;
930			}
931		} );
932		// Make sure only one callback list will be used
933		deferred.done( failDeferred.cancel ).fail( deferred.cancel );
934		// Unexpose cancel
935		delete deferred.cancel;
936		// Call given func if any
937		if ( func ) {
938			func.call( deferred, deferred );
939		}
940		return deferred;
941	},
942
943	// Deferred helper
944	when: function( object ) {
945		var lastIndex = arguments.length,
946			deferred = lastIndex <= 1 && object && jQuery.isFunction( object.promise ) ?
947				object :
948				jQuery.Deferred(),
949			promise = deferred.promise();
950
951		if ( lastIndex > 1 ) {
952			var array = slice.call( arguments, 0 ),
953				count = lastIndex,
954				iCallback = function( index ) {
955					return function( value ) {
956						array[ index ] = arguments.length > 1 ? slice.call( arguments, 0 ) : value;
957						if ( !( --count ) ) {
958							deferred.resolveWith( promise, array );
959						}
960					};
961				};
962			while( ( lastIndex-- ) ) {
963				object = array[ lastIndex ];
964				if ( object && jQuery.isFunction( object.promise ) ) {
965					object.promise().then( iCallback(lastIndex), deferred.reject );
966				} else {
967					--count;
968				}
969			}
970			if ( !count ) {
971				deferred.resolveWith( promise, array );
972			}
973		} else if ( deferred !== object ) {
974			deferred.resolve( object );
975		}
976		return promise;
977	},
978
979	// Use of jQuery.browser is frowned upon.
980	// More details: http://docs.jquery.com/Utilities/jQuery.browser
981	uaMatch: function( ua ) {
982		ua = ua.toLowerCase();
983
984		var match = rwebkit.exec( ua ) ||
985			ropera.exec( ua ) ||
986			rmsie.exec( ua ) ||
987			ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
988			[];
989
990		return { browser: match[1] || "", version: match[2] || "0" };
991	},
992
993	sub: function() {
994		function jQuerySubclass( selector, context ) {
995			return new jQuerySubclass.fn.init( selector, context );
996		}
997		jQuery.extend( true, jQuerySubclass, this );
998		jQuerySubclass.superclass = this;
999		jQuerySubclass.fn = jQuerySubclass.prototype = this();
1000		jQuerySubclass.fn.constructor = jQuerySubclass;
1001		jQuerySubclass.subclass = this.subclass;
1002		jQuerySubclass.fn.init = function init( selector, context ) {
1003			if ( context && context instanceof jQuery && !(context instanceof jQuerySubclass) ) {
1004				context = jQuerySubclass(context);
1005			}
1006
1007			return jQuery.fn.init.call( this, selector, context, rootjQuerySubclass );
1008		};
1009		jQuerySubclass.fn.init.prototype = jQuerySubclass.fn;
1010		var rootjQuerySubclass = jQuerySubclass(document);
1011		return jQuerySubclass;
1012	},
1013
1014	browser: {}
1015});
1016
1017// Create readyList deferred
1018readyList = jQuery._Deferred();
1019
1020// Populate the class2type map
1021jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
1022	class2type[ "[object " + name + "]" ] = name.toLowerCase();
1023});
1024
1025browserMatch = jQuery.uaMatch( userAgent );
1026if ( browserMatch.browser ) {
1027	jQuery.browser[ browserMatch.browser ] = true;
1028	jQuery.browser.version = browserMatch.version;
1029}
1030
1031// Deprecated, use jQuery.browser.webkit instead
1032if ( jQuery.browser.webkit ) {
1033	jQuery.browser.safari = true;
1034}
1035
1036if ( indexOf ) {
1037	jQuery.inArray = function( elem, array ) {
1038		return indexOf.call( array, elem );
1039	};
1040}
1041

1042// IE doesn't match non-breaking spaces with \s
1043if ( rnotwhite.test( "\xA0" ) ) {
1044	trimLeft = /^[\s\xA0]+/;
1045	trimRight = /[\s\xA0]+$/;
1046}
1047
1048// All jQuery objects should point back to these
1049rootjQuery = jQuery(document);
1050
1051// Cleanup functions for the document ready method
1052if ( document.addEventListener ) {
1053	DOMContentLoaded = function() {
1054		document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
1055		jQuery.ready();
1056	};
1057
1058} else if ( document.attachEvent ) {
1059	DOMContentLoaded = function() {
1060		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
1061		if ( document.readyState === "complete" ) {
1062			document.detachEvent( "onreadystatechange", DOMContentLoaded );
1063			jQuery.ready();
1064		}
1065	};
1066}
1067
1068// The DOM ready check for Internet Explorer
1069function doScrollCheck() {
1070	if ( jQuery.isReady ) {
1071		return;
1072	}
1073
1074	try {
1075		// If IE is used, use the trick by Diego Perini
1076		// http://javascript.nwbox.com/IEContentLoaded/
1077		document.documentElement.doScroll("left");
1078	} catch(e) {
1079		setTimeout( doScrollCheck, 1 );
1080		return;
1081	}
1082
1083	// and execute any waiting functions
1084	jQuery.ready();
1085}
1086
1087// Expose jQuery to the global object
1088return jQuery;
1089
1090})();
1091
1092
1093(function() {
1094
1095	jQuery.support = {};
1096
1097	var div = document.createElement("div");
1098
1099	div.style.display = "none";
1100	div.innerHTML = "   <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
1101
1102	var all = div.getElementsByTagName("*"),
1103		a = div.getElementsByTagName("a")[0],
1104		select = document.createElement("select"),
1105		opt = select.appendChild( document.createElement("option") ),
1106		input = div.getElementsByTagName("input")[0];
1107
1108	// Can't get basic test support
1109	if ( !all || !all.length || !a ) {
1110		return;
1111	}
1112
1113	jQuery.support = {
1114		// IE strips leading whitespace when .innerHTML is used
1115		leadingWhitespace: div.firstChild.nodeType === 3,
1116
1117		// Make sure that tbody elements aren't automatically inserted
1118		// IE will insert them into empty tables
1119		tbody: !div.getElementsByTagName("tbody").length,
1120
1121		// Make sure that link elements get serialized correctly by innerHTML
1122		// This requires a wrapper element in IE
1123		htmlSerialize: !!div.getElementsByTagName("link").length,
1124
1125		// Get the style information from getAttribute
1126		// (IE uses .cssText insted)
1127		style: /red/.test( a.getAttribute("style") ),
1128
1129		// Make sure that URLs aren't manipulated
1130		// (IE normalizes it by default)
1131		hrefNormalized: a.getAttribute("href") === "/a",
1132
1133		// Make sure that element opacity exists
1134		// (IE uses filter instead)
1135		// Use a regex to work around a WebKit issue. See #5145
1136		opacity: /^0.55$/.test( a.style.opacity ),
1137
1138		// Verify style float existence
1139		// (IE uses styleFloat instead of cssFloat)
1140		cssFloat: !!a.style.cssFloat,
1141
1142		// Make sure that if no value is specified for a checkbox
1143		// that it defaults to "on".
1144		// (WebKit defaults to "" instead)
1145		checkOn: input.value === "on",
1146
1147		// Make sure that a selected-by-default option has a working selected property.
1148		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1149		optSelected: opt.selected,
1150
1151		// Will be defined later
1152		deleteExpando: true,
1153		optDisabled: false,
1154		checkClone: false,
1155		noCloneEvent: true,
1156		noCloneChecked: true,
1157		boxModel: null,
1158		inlineBlockNeedsLayout: false,
1159		shrinkWrapBlocks: false,
1160		reliableHiddenOffsets: true
1161	};
1162
1163	input.checked = true;
1164	jQuery.support.noCloneChecked = input.cloneNode( true ).checked;
1165
1166	// Make sure that the options inside disabled selects aren't marked as disabled
1167	// (WebKit marks them as diabled)
1168	select.disabled = true;
1169	jQuery.support.optDisabled = !opt.disabled;
1170
1171	var _scriptEval = null;
1172	jQuery.support.scriptEval = function() {
1173		if ( _scriptEval === null ) {
1174			var root = document.documentElement,
1175				script = document.createElement("script"),
1176				id = "script" + jQuery.now();
1177
1178			try {
1179				script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
1180			} catch(e) {}
1181
1182			root.insertBefore( script, root.firstChild );
1183
1184			// Make sure that the execution of code works by injecting a script
1185			// tag with appendChild/createTextNode
1186			// (IE doesn't support this, fails, and uses .text instead)
1187			if ( window[ id ] ) {
1188				_scriptEval = true;
1189				delete window[ id ];
1190			} else {
1191				_scriptEval = false;

1192			}
1193
1194			root.removeChild( script );
1195			// release memory in IE
1196			root = script = id  = null;
1197		}
1198
1199		return _scriptEval;
1200	};
1201
1202	// Test to see if it's possible to delete an expando from an element
1203	// Fails in Internet Explorer
1204	try {
1205		delete div.test;
1206
1207	} catch(e) {
1208		jQuery.support.deleteExpando = false;
1209	}
1210
1211	if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1212		div.attachEvent("onclick", function click() {
1213			// Cloning a node shouldn't copy over any
1214			// bound event handlers (IE does this)
1215			jQuery.support.noCloneEvent = false;
1216			div.detachEvent("onclick", click);
1217		});
1218		div.cloneNode(true).fireEvent("onclick");
1219	}
1220
1221	div = document.createElement("div");
1222	div.innerHTML = "<input type='radio' name='radiotest' checked='checked'/>";
1223
1224	var fragment = document.createDocumentFragment();
1225	fragment.appendChild( div.firstChild );
1226
1227	// WebKit doesn't clone checked state correctly in fragments
1228	jQuery.support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
1229
1230	// Figure out if the W3C box model works as expected
1231	// document.body must exist before we can do this
1232	jQuery(function() {
1233		var div = document.createElement("div"),
1234			body = document.getElementsByTagName("body")[0];
1235
1236		// Frameset documents with no body should not run this code
1237		if ( !body ) {
1238			return;
1239		}
1240
1241		div.style.width = div.style.paddingLeft = "1px";
1242		body.appendChild( div );
1243		jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
1244
1245		if ( "zoom" in div.style ) {
1246			// Check if natively block-level elements act like inline-block
1247			// elements when setting their display to 'inline' and giving
1248			// them layout
1249			// (IE < 8 does this)
1250			div.style.display = "inline";
1251			div.style.zoom = 1;
1252			jQuery.support.inlineBlockNeedsLayout = div.offsetWidth === 2;
1253
1254			// Check if elements with layout shrink-wrap their children
1255			// (IE 6 does this)
1256			div.style.display = "";
1257			div.innerHTML = "<div style='width:4px;'></div>";
1258			jQuery.support.shrinkWrapBlocks = div.offsetWidth !== 2;
1259		}
1260
1261		div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
1262		var tds = div.getElementsByTagName("td");
1263
1264		// Check if table cells still have offsetWidth/Height when they are set
1265		// to display:none and there are still other visible table cells in a
1266		// table row; if so, offsetWidth/Height are not reliable for use when
1267		// determining if an element has been hidden directly using
1268		// display:none (it is still safe to use offsets if a parent element is
1269		// hidden; don safety goggles and see bug #4512 for more information).
1270		// (only IE 8 fails this test)
1271		jQuery.support.reliableHiddenOffsets = tds[0].offsetHeight === 0;
1272
1273		tds[0].style.display = "";
1274		tds[1].style.display = "none";
1275
1276		// Check if empty table cells still have offsetWidth/Height
1277		// (IE < 8 fail this test)
1278		jQuery.support.reliableHiddenOffsets = jQuery.support.reliableHiddenOffsets && tds[0].offsetHeight === 0;
1279		div.innerHTML = "";
1280
1281		body.removeChild( div ).style.display = "none";
1282		div = tds = null;
1283	});
1284
1285	// Technique from Juriy Zaytsev
1286	// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
1287	var eventSupported = function( eventName ) {
1288		var el = document.createElement("div");
1289		eventName = "on" + eventName;
1290
1291		// We only care about the case where non-standard event systems
1292		// are used, namely in IE. Short-circuiting here helps us to
1293		// avoid an eval call (in setAttribute) which can cause CSP
1294		// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1295		if ( !el.attachEvent ) {
1296			return true;
1297		}
1298
1299		var isSupported = (eventName in el);
1300		if ( !isSupported ) {
1301			el.setAttribute(eventName, "return;");
1302			isSupported = typeof el[eventName] === "function";
1303		}
1304		el = null;
1305
1306		return isSupported;
1307	};
1308
1309	jQuery.support.submitBubbles = eventSupported("submit");
1310	jQuery.support.changeBubbles = eventSupported("change");
1311
1312	// release memory in IE
1313	div = all = a = null;
1314})();
1315
1316
1317
1318var rbrace = /^(?:\{.*\}|\[.*\])$/;
1319
1320jQuery.extend({
1321	cache: {},
1322
1323	// Please use with caution
1324	uuid: 0,
1325
1326	// Unique for each copy of jQuery on the page
1327	// Non-digits removed to match rinlinejQuery
1328	expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1329
1330	// The following elements throw uncatchable exceptions if you
1331	// attempt to add expando properties to them.
1332	noData: {
1333		"embed": true,
1334		// Ban all objects except for Flash (which handle expandos)
1335		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1336		"applet": true
1337	},
1338
1339	hasData: function( elem ) {
1340		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1341
1342		return !!elem && !isEmptyDataObject( elem );
1343	},
1344
1345	data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1346		if ( !jQuery.acceptData( elem ) ) {
1347			return;
1348		}
1349
1350		var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,
1351
1352			// We have to handle DOM nodes and JS objects differently because IE6-7
1353			// can't GC object references properly across the DOM-JS boundary
1354			isNode = elem.nodeType,
1355
1356			// Only DOM nodes need the global jQuery cache; JS object data is
1357			// attached directly to the object so GC can occur automatically
1358			cache = isNode ? jQuery.cache : elem,
1359
1360			// Only defining an ID for JS objects if its cache already exists allows
1361			// the code to shortcut on the same path as a DOM node with no cache
1362			id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
1363
1364		// Avoid doing any more work than we need to when trying to get data on an
1365		// object that has no data at all
1366		if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
1367			return;
1368		}
1369
1370		if ( !id ) {
1371			// Only DOM nodes need a new unique ID for each element since their data
1372			// ends up in the global cache
1373			if ( isNode ) {
1374				elem[ jQuery.expando ] = id = ++jQuery.uuid;
1375			} else {
1376				id = jQuery.expando;
1377			}
1378		}
1379
1380		if ( !cache[ id ] ) {
1381			cache[ id ] = {};
1382
1383			// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1384			// metadata on plain JS objects when the object is serialized using
1385			// JSON.stringify
1386			if ( !isNode ) {
1387				cache[ id ].toJSON = jQuery.noop;
1388			}
1389		}
1390

1391		// An object can be passed to jQuery.data instead of a key/value pair; this gets
1392		// shallow copied over onto the existing cache
1393		if ( typeof name === "object" || typeof name === "function" ) {
1394			if ( pvt ) {
1395				cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
1396			} else {
1397				cache[ id ] = jQuery.extend(cache[ id ], name);
1398			}
1399		}
1400
1401		thisCache = cache[ id ];
1402
1403		// Internal jQuery data is stored in a separate object inside the object's data
1404		// cache in order to avoid key collisions between internal data and user-defined
1405		// data
1406		if ( pvt ) {
1407			if ( !thisCache[ internalKey ] ) {
1408				thisCache[ internalKey ] = {};
1409			}
1410
1411			thisCache = thisCache[ internalKey ];
1412		}
1413
1414		if ( data !== undefined ) {
1415			thisCache[ name ] = data;
1416		}
1417
1418		// TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
1419		// not attempt to inspect the internal events object using jQuery.data, as this
1420		// internal data object is undocumented and subject to change.
1421		if ( name === "events" && !thisCache[name] ) {
1422			return thisCache[ internalKey ] && thisCache[ internalKey ].events;
1423		}
1424
1425		return getByName ? thisCache[ name ] : thisCache;
1426	},
1427
1428	removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1429		if ( !jQuery.acceptData( elem ) ) {
1430			return;
1431		}
1432
1433		var internalKey = jQuery.expando, isNode = elem.nodeType,
1434
1435			// See jQuery.data for more information
1436			cache = isNode ? jQuery.cache : elem,
1437
1438			// See jQuery.data for more information
1439			id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
1440
1441		// If there is already no cache entry for this object, there is no
1442		// purpose in continuing
1443		if ( !cache[ id ] ) {
1444			return;
1445		}
1446
1447		if ( name ) {
1448			var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
1449
1450			if ( thisCache ) {
1451				delete thisCache[ name ];
1452
1453				// If there is no data left in the cache, we want to continue
1454				// and let the cache object itself get destroyed
1455				if ( !isEmptyDataObject(thisCache) ) {
1456					return;
1457				}
1458			}
1459		}
1460
1461		// See jQuery.data for more information
1462		if ( pvt ) {
1463			delete cache[ id ][ internalKey ];
1464
1465			// Don't destroy the parent cache unless the internal data object
1466			// had been the only thing left in it
1467			if ( !isEmptyDataObject(cache[ id ]) ) {
1468				return;
1469			}
1470		}
1471
1472		var internalCache = cache[ id ][ internalKey ];
1473
1474		// Browsers that fail expando deletion also refuse to delete expandos on
1475		// the window, but it will allow it on all other JS objects; other browsers
1476		// don't care
1477		if ( jQuery.support.deleteExpando || cache != window ) {
1478			delete cache[ id ];
1479		} else {
1480			cache[ id ] = null;
1481		}
1482
1483		// We destroyed the entire user cache at once because it's faster than
1484		// iterating through each key, but we need to continue to persist internal
1485		// data if it existed
1486		if ( internalCache ) {
1487			cache[ id ] = {};
1488			// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1489			// metadata on plain JS objects when the object is serialized using
1490			// JSON.stringify
1491			if ( !isNode ) {
1492				cache[ id ].toJSON = jQuery.noop;
1493			}
1494
1495			cache[ id ][ internalKey ] = internalCache;
1496
1497		// Otherwise, we need to eliminate the expando on the node to avoid
1498		// false lookups in the cache for entries that no longer exist
1499		} else if ( isNode ) {
1500			// IE does not allow us to delete expando properties from nodes,
1501			// nor does it have a removeAttribute function on Document nodes;
1502			// we must handle all of these cases
1503			if ( jQuery.support.deleteExpando ) {
1504				delete elem[ jQuery.expando ];
1505			} else if ( elem.removeAttribute ) {
1506				elem.removeAttribute( jQuery.expando );
1507			} else {
1508				elem[ jQuery.expando ] = null;
1509			}
1510		}
1511	},
1512
1513	// For internal use only.
1514	_data: function( elem, name, data ) {
1515		return jQuery.data( elem, name, data, true );
1516	},
1517
1518	// A method for determining if a DOM node can handle the data expando
1519	acceptData: function( elem ) {
1520		if ( elem.nodeName ) {
1521			var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1522
1523			if ( match ) {
1524				return !(match === true || elem.getAttribute("classid") !== match);
1525			}
1526		}
1527
1528		return true;
1529	}
1530});
1531
1532jQuery.fn.extend({
1533	data: function( key, value ) {
1534		var data = null;
1535
1536		if ( typeof key === "undefined" ) {
1537			if ( this.length ) {
1538				data = jQuery.data( this[0] );
1539
1540				if ( this[0].nodeType === 1 ) {
1541					var attr = this[0].attributes, name;
1542					for ( var i = 0, l = attr.length; i < l; i++ ) {
1543						name = attr[i].name;
1544

1545						if ( name.indexOf( "data-" ) === 0 ) {
1546							name = name.substr( 5 );
1547							dataAttr( this[0], name, data[ name ] );
1548						}
1549					}
1550				}
1551			}
1552
1553			return data;
1554
1555		} else if ( typeof key === "object" ) {
1556			return this.each(function() {
1557				jQuery.data( this, key );
1558			});
1559		}
1560
1561		var parts = key.split(".");
1562		parts[1] = parts[1] ? "." + parts[1] : "";
1563
1564		if ( value === undefined ) {
1565			data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1566
1567			// Try to fetch any internally stored data first
1568			if ( data === undefined && this.length ) {
1569				data = jQuery.data( this[0], key );
1570				data = dataAttr( this[0], key, data );
1571			}
1572
1573			return data === undefined && parts[1] ?
1574				this.data( parts[0] ) :
1575				data;
1576
1577		} else {
1578			return this.each(function() {
1579				var $this = jQuery( this ),
1580					args = [ parts[0], value ];
1581
1582				$this.triggerHandler( "setData" + parts[1] + "!", args );
1583				jQuery.data( this, key, value );
1584				$this.triggerHandler( "changeData" + parts[1] + "!", args );
1585			});
1586		}
1587	},
1588
1589	removeData: function( key ) {
1590		return this.each(function() {
1591			jQuery.removeData( this, key );
1592		});
1593	}
1594});
1595
1596function dataAttr( elem, key, data ) {
1597	// If nothing was found internally, try to fetch any
1598	// data from the HTML5 data-* attribute
1599	if ( data === undefined && elem.nodeType === 1 ) {
1600		data = elem.getAttribute( "data-" + key );
1601
1602		if ( typeof data === "string" ) {
1603			try {
1604				data = data === "true" ? true :
1605				data === "false" ? false :
1606				data === "null" ? null :
1607				!jQuery.isNaN( data ) ? parseFloat( data ) :
1608					rbrace.test( data ) ? jQuery.parseJSON( data ) :
1609					data;
1610			} catch( e ) {}
1611
1612			// Make sure we set the data so it isn't changed later
1613			jQuery.data( elem, key, data );
1614
1615		} else {
1616			data = undefined;
1617		}
1618	}
1619
1620	return data;
1621}
1622
1623// TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
1624// property to be considered empty objects; this property always exists in
1625// order to make sure JSON.stringify does not expose internal metadata
1626function isEmptyDataObject( obj ) {
1627	for ( var name in obj ) {
1628		if ( name !== "toJSON" ) {
1629			return false;
1630		}
1631	}
1632
1633	return true;
1634}
1635
1636
1637
1638
1639jQuery.extend({
1640	queue: function( elem, type, data ) {
1641		if ( !elem ) {
1642			return;
1643		}
1644
1645		type = (type || "fx") + "queue";
1646		var q = jQuery._data( elem, type );
1647
1648		// Speed up dequeue by getting out quickly if this is just a lookup
1649		if ( !data ) {
1650			return q || [];
1651		}
1652
1653		if ( !q || jQuery.isArray(data) ) {
1654			q = jQuery._data( elem, type, jQuery.makeArray(data) );
1655
1656		} else {
1657			q.push( data );
1658		}
1659
1660		return q;
1661	},
1662
1663	dequeue: function( elem, type ) {
1664		type = type || "fx";
1665
1666		var queue = jQuery.queue( elem, type ),
1667			fn = queue.shift();
1668
1669		// If the fx queue is dequeued, always remove the progress sentinel
1670		if ( fn === "inprogress" ) {
1671			fn = queue.shift();
1672		}
1673
1674		if ( fn ) {
1675			// Add a progress sentinel to prevent the fx queue from being
1676			// automatically dequeued
1677			if ( type === "fx" ) {
1678				queue.unshift("inprogress");
1679			}
1680
1681			fn.call(elem, function() {
1682				jQuery.dequeue(elem, type);
1683			});
1684		}
1685
1686		if ( !queue.length ) {
1687			jQuery.removeData( elem, type + "queue", true );
1688		}
1689	}
1690});
1691
1692jQuery.fn.extend({
1693	queue: function( type, data ) {
1694		if ( typeof type !== "string" ) {
1695			data = type;
1696			type = "fx";
1697		}
1698
1699		if ( data === undefined ) {
1700			return jQuery.queue( this[0], type );
1701		}
1702		return this.each(function( i ) {
1703			var queue = jQuery.queue( this, type, data );
1704
1705			if ( type === "fx" && queue[0] !== "inprogress" ) {
1706				jQuery.dequeue( this, type );
1707			}
1708		});
1709	},
1710	dequeue: function( type ) {
1711		return this.each(function() {
1712			jQuery.dequeue( this, type );
1713		});
1714	},
1715
1716	// Based off of the plugin by Clint Helfers, with permission.
1717	// http://blindsignals.com/index.php/2009/07/jquery-delay/
1718	delay: function( time, type ) {
1719		time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1720		type = type || "fx";
1721
1722		return this.queue( type, function() {
1723			var elem = this;
1724			setTimeout(function() {
1725				jQuery.dequeue( elem, type );
1726			}, time );
1727		});
1728	},
1729
1730	clearQueue: function( type ) {
1731		return this.queue( type || "fx", [] );
1732	}
1733});
1734
1735
1736
1737
1738var rclass = /[\n\t\r]/g,
1739	rspaces = /\s+/,
1740	rreturn = /\r/g,
1741	rspecialurl = /^(?:href|src|style)$/,
1742	rtype = /^(?:button|input)$/i,
1743	rfocusable = /^(?:button|input|object|select|textarea)$/i,
1744	rclickable = /^a(?:rea)?$/i,
1745	rradiocheck = /^(?:radio|checkbox)$/i;
1746
1747jQuery.props = {
1748	"for": "htmlFor",
1749	"class": "className",
1750	readonly: "readOnly",
1751	maxlength: "maxLength",
1752	cellspacing: "cellSpacing",
1753	rowspan: "rowSpan",
1754	colspan: "colSpan",
1755	tabindex: "tabIndex",
1756	usemap: "useMap",
1757	frameborder: "frameBorder"
1758};
1759
1760jQuery.fn.extend({
1761	attr: function( name, value ) {
1762		return jQuery.access( this, name, value, true, jQuery.attr );
1763	},
1764
1765	removeAttr: function( name, fn ) {
1766		return this.each(function(){
1767			jQuery.attr( this, name, "" );
1768			if ( this.nodeType === 1 ) {
1769				this.removeAttribute( name );
1770			}
1771		});
1772	},
1773
1774	addClass: function( value ) {
1775		if ( jQuery.isFunction(value) ) {
1776			return this.each(function(i) {
1777				var self = jQuery(this);
1778				self.addClass( value.call(this, i, self.attr("class")) );
1779			});
1780		}
1781
1782		if ( value && typeof value === "string" ) {
1783			var classNames = (value || "").split( rspaces );
1784
1785			for ( var i = 0, l = this.length; i < l; i++ ) {
1786				var elem = this[i];
1787
1788				if ( elem.nodeType === 1 ) {
1789					if ( !elem.className ) {
1790						elem.className = value;
1791
1792					} else {
1793						var className = " " + elem.className + " ",
1794							setClass = elem.className;
1795
1796						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1797							if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
1798								setClass += " " + classNames[c];
1799							}
1800						}
1801						elem.className = jQuery.trim( setClass );
1802					}
1803				}
1804			}
1805		}
1806
1807		return this;
1808	},
1809
1810	removeClass: function( value ) {
1811		if ( jQuery.isFunction(value) ) {
1812			return this.each(function(i) {
1813				var self = jQuery(this);
1814				self.removeClass( value.call(this, i, self.attr("class")) );
1815			});
1816		}
1817
1818		if ( (value && typeof value === "string") || value === undefined ) {
1819			var classNames = (value || "").split( rspaces );
1820
1821			for ( var i = 0, l = this.length; i < l; i++ ) {
1822				var elem = this[i];
1823
1824				if ( elem.nodeType === 1 && elem.className ) {
1825					if ( value ) {
1826						var className = (" " + elem.className + " ").replace(rclass, " ");
1827						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1828							className = className.replace(" " + classNames[c] + " ", " ");
1829						}
1830						elem.className = jQuery.trim( className );
1831
1832					} else {
1833						elem.className = "";
1834					}
1835				}
1836			}
1837		}
1838
1839		return this;
1840	},
1841
1842	toggleClass: function( value, stateVal ) {
1843		var type = typeof value,
1844			isBool = typeof stateVal === "boolean";
1845
1846		if ( jQuery.isFunction( value ) ) {
1847			return this.each(function(i) {
1848				var self = jQuery(this);
1849				self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
1850			});
1851		}
1852
1853		return this.each(function() {
1854			if ( type === "string" ) {
1855				// toggle individual class names
1856				var className,
1857					i = 0,
1858					self = jQuery( this ),
1859					state = stateVal,
1860					classNames = value.split( rspaces );
1861
1862				while ( (className = classNames[ i++ ]) ) {
1863					// check each className given, space seperated list
1864					state = isBool ? state : !self.hasClass( className );
1865					self[ state ? "addClass" : "removeClass" ]( className );
1866				}
1867
1868			} else if ( type === "undefined" || type === "boolean" ) {
1869				if ( this.className ) {
1870					// store className if set
1871					jQuery._data( this, "__className__", this.className );
1872				}
1873
1874				// toggle whole className
1875				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
1876			}
1877		});
1878	},
1879
1880	hasClass: function( selector ) {
1881		var className = " " + selector + " ";
1882		for ( var i = 0, l = this.length; i < l; i++ ) {
1883			if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
1884				return true;
1885			}
1886		}
1887
1888		return false;

1889	},
1890
1891	val: function( value ) {
1892		if ( !arguments.length ) {
1893			var elem = this[0];
1894
1895			if ( elem ) {
1896				if ( jQuery.nodeName( elem, "option" ) ) {
1897					// attributes.value is undefined in Blackberry 4.7 but
1898					// uses .value. See #6932
1899					var val = elem.attributes.value;
1900					return !val || val.specified ? elem.value : elem.text;
1901				}
1902
1903				// We need to handle select boxes special
1904				if ( jQuery.nodeName( elem, "select" ) ) {
1905					var index = elem.selectedIndex,
1906						values = [],
1907						options = elem.options,
1908						one = elem.type === "select-one";
1909
1910					// Nothing was selected
1911					if ( index < 0 ) {
1912						return null;
1913					}
1914
1915					// Loop through all the selected options
1916					for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
1917						var option = options[ i ];
1918
1919						// Don't return options that are disabled or in a disabled optgroup
1920						if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
1921								(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
1922
1923							// Get the specific value for the option
1924							value = jQuery(option).val();
1925
1926							// We don't need an array for one selects
1927							if ( one ) {
1928								return value;
1929							}
1930
1931							// Multi-Selects return an array
1932							values.push( value );
1933						}
1934					}
1935
1936					// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
1937					if ( one && !values.length && options.length ) {
1938						return jQuery( options[ index ] ).val();
1939					}
1940
1941					return values;
1942				}
1943
1944				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
1945				if ( rradiocheck.test( elem.type ) && !jQuery.support.checkOn ) {
1946					return elem.getAttribute("value") === null ? "on" : elem.value;
1947				}
1948
1949				// Everything else, we just grab the value
1950				return (elem.value || "").replace(rreturn, "");
1951
1952			}
1953
1954			return undefined;
1955		}
1956
1957		var isFunction = jQuery.isFunction(value);
1958
1959		return this.each(function(i) {
1960			var self = jQuery(this), val = value;
1961
1962			if ( this.nodeType !== 1 ) {
1963				return;
1964			}
1965
1966			if ( isFunction ) {
1967				val = value.call(this, i, self.val());
1968			}
1969
1970			// Treat null/undefined as ""; convert numbers to string
1971			if ( val == null ) {
1972				val = "";
1973			} else if ( typeof val === "number" ) {
1974				val += "";
1975			} else if ( jQuery.isArray(val) ) {
1976				val = jQuery.map(val, function (value) {
1977					return value == null ? "" : value + "";
1978				});
1979			}
1980
1981			if ( jQuery.isArray(val) && rradiocheck.test( this.type ) ) {
1982				this.checked = jQuery.inArray( self.val(), val ) >= 0;
1983
1984			} else if ( jQuery.nodeName( this, "select" ) ) {
1985				var values = jQuery.makeArray(val);
1986
1987				jQuery( "option", this ).each(function() {
1988					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
1989				});
1990
1991				if ( !values.length ) {
1992					this.selectedIndex = -1;
1993				}
1994
1995			} else {
1996				this.value = val;
1997			}
1998		});
1999	}
2000});
2001
2002jQuery.extend({
2003	attrFn: {
2004		val: true,
2005		css: true,
2006		html: true,
2007		text: true,
2008		data: true,
2009		width: true,
2010		height: true,
2011		offset: true
2012	},
2013
2014	attr: function( elem, name, value, pass ) {
2015		// don't get/set attributes on text, comment and attribute nodes
2016		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || elem.nodeType === 2 ) {
2017			return undefined;
2018		}
2019
2020		if ( pass && name in jQuery.attrFn ) {
2021			return jQuery(elem)[name](value);
2022		}
2023
2024		var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
2025			// Whether we are setting (or getting)
2026			set = value !== undefined;
2027
2028		// Try to normalize/fix the name
2029		name = notxml && jQuery.props[ name ] || name;
2030
2031		// Only do all the following if this is a node (faster for style)
2032		if ( elem.nodeType === 1 ) {
2033			// These attributes require special treatment
2034			var special = rspecialurl.test( name );
2035
2036			// Safari mis-reports the default selected property of an option
2037			// Accessing the parent's selectedIndex property fixes it
2038			if ( name === "selected" && !jQuery.support.optSelected ) {
2039				var parent = elem.parentNode;
2040				if ( parent ) {
2041					parent.selectedIndex;
2042
2043					// Make sure that it also works with optgroups, see #5701
2044					if ( parent.parentNode ) {
2045						parent.parentNode.selectedIndex;
2046					}
2047				}
2048			}
2049
2050			// If applicable, access the attribute via the DOM 0 way
2051			// 'in' checks fail in Blackberry 4.7 #6931
2052			if ( (name in elem || elem[ name ] !== undefined) && notxml && !special ) {
2053				if ( set ) {
2054					// We can't allow the type property to be changed (since it causes problems in IE)

2055					if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
2056						jQuery.error( "type property can't be changed" );
2057					}
2058
2059					if ( value === null ) {
2060						if ( elem.nodeType === 1 ) {
2061							elem.removeAttribute( name );
2062						}
2063
2064					} else {
2065						elem[ name ] = value;
2066					}
2067				}
2068
2069				// browsers index elements by id/name on forms, give priority to attributes.
2070				if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
2071					return elem.getAttributeNode( name ).nodeValue;
2072				}
2073
2074				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2075				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2076				if ( name === "tabIndex" ) {
2077					var attributeNode = elem.getAttributeNode( "tabIndex" );
2078
2079					return attributeNode && attributeNode.specified ?
2080						attributeNode.value :
2081						rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
2082							0 :
2083							undefined;
2084				}
2085
2086				return elem[ name ];
2087			}
2088
2089			if ( !jQuery.support.style && notxml && name === "style" ) {
2090				if ( set ) {
2091					elem.style.cssText = "" + value;
2092				}
2093
2094				return elem.style.cssText;
2095			}
2096
2097			if ( set ) {
2098				// convert the value to a string (all browsers do this but IE) see #1070
2099				elem.setAttribute( name, "" + value );
2100			}
2101
2102			// Ensure that missing attributes return undefined
2103			// Blackberry 4.7 returns "" from getAttribute #6938
2104			if ( !elem.attributes[ name ] && (elem.hasAttribute && !elem.hasAttribute( name )) ) {
2105				return undefined;
2106			}
2107
2108			var attr = !jQuery.support.hrefNormalized && notxml && special ?
2109					// Some attributes require a special call on IE
2110					elem.getAttribute( name, 2 ) :
2111					elem.getAttribute( name );
2112
2113			// Non-existent attributes return null, we normalize to undefined
2114			return attr === null ? undefined : attr;
2115		}
2116		// Handle everything which isn't a DOM element node
2117		if ( set ) {
2118			elem[ name ] = value;
2119		}
2120		return elem[ name ];
2121	}
2122});
2123
2124
2125
2126
2127var rnamespaces = /\.(.*)$/,
2128	rformElems = /^(?:textarea|input|select)$/i,
2129	rperiod = /\./g,
2130	rspace = / /g,
2131	rescape = /[^\w\s.|`]/g,
2132	fcleanup = function( nm ) {
2133		return nm.replace(rescape, "\\$&");
2134	};
2135
2136/*
2137 * A number of helper functions used for managing events.
2138 * Many of the ideas behind this code originated from
2139 * Dean Edwards' addEvent library.
2140 */
2141jQuery.event = {
2142
2143	// Bind an event to an element
2144	// Original by Dean Edwards
2145	add: function( elem, types, handler, data ) {
2146		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2147			return;
2148		}
2149
2150		// TODO :: Use a try/catch until it's safe to pull this out (likely 1.6)
2151		// Minor release fix for bug #8018
2152		try {
2153			// For whatever reason, IE has trouble passing the window object
2154			// around, causing it to be cloned in the process
2155			if ( jQuery.isWindow( elem ) && ( elem !== window && !elem.frameElement ) ) {
2156				elem = window;
2157			}
2158		}
2159		catch ( e ) {}
2160
2161		if ( handler === false ) {
2162			handler = returnFalse;
2163		} else if ( !handler ) {
2164			// Fixes bug #7229. Fix recommended by jdalton
2165			return;
2166		}
2167
2168		var handleObjIn, handleObj;
2169
2170		if ( handler.handler ) {
2171			handleObjIn = handler;
2172			handler = handleObjIn.handler;
2173		}
2174
2175		// Make sure that the function being executed has a unique ID
2176		if ( !handler.guid ) {
2177			handler.guid = jQuery.guid++;
2178		}
2179
2180		// Init the element's event structure
2181		var elemData = jQuery._data( elem );
2182
2183		// If no elemData is found then we must be trying to bind to one of the
2184		// banned noData elements
2185		if ( !elemData ) {
2186			return;
2187		}
2188
2189		var events = elemData.events,
2190			eventHandle = elemData.handle;
2191
2192		if ( !events ) {
2193			elemData.events = events = {};
2194		}
2195
2196		if ( !eventHandle ) {
2197			elemData.handle = eventHandle = function() {
2198				// Handle the second event of a trigger and when
2199				// an event is called after a page has unloaded
2200				return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
2201					jQuery.event.handle.apply( eventHandle.elem, arguments ) :
2202					undefined;
2203			};
2204		}
2205
2206		// Add elem as a property of the handle function
2207		// This is to prevent a memory leak with non-native events in IE.
2208		eventHandle.elem = elem;
2209
2210		// Handle multiple events separated by a space
2211		// jQuery(...).bind("mouseover mouseout", fn);
2212		types = types.split(" ");
2213
2214		var type, i = 0, namespaces;
2215
2216		while ( (type = types[ i++ ]) ) {
2217			handleObj = handleObjIn ?
2218				jQuery.extend({}, handleObjIn) :
2219				{ handler: handler, data: data };
2220
2221			// Namespaced event handlers
2222			if ( type.indexOf(".") > -1 ) {
2223				namespaces = type.split(".");
2224				type = namespaces.shift();
2225				handleObj.namespace = namespaces.slice(0).sort().join(".");
2226
2227			} else {
2228				namespaces = [];
2229				handleObj.namespace = "";
2230			}
2231
2232			handleObj.type = type;
2233			if ( !handleObj.guid ) {
2234				handleObj.guid = handler.guid;
2235			}
2236

2237			// Get the current list of functions bound to this event
2238			var handlers = events[ type ],
2239				special = jQuery.event.special[ type ] || {};
2240
2241			// Init the event handler queue
2242			if ( !handlers ) {
2243				handlers = events[ type ] = [];
2244
2245				// Check for a special event handler
2246				// Only use addEventListener/attachEvent if the special
2247				// events handler returns false
2248				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2249					// Bind the global event handler to the element
2250					if ( elem.addEventListener ) {
2251						elem.addEventListener( type, eventHandle, false );
2252
2253					} else if ( elem.attachEvent ) {
2254						elem.attachEvent( "on" + type, eventHandle );
2255					}
2256				}
2257			}
2258
2259			if ( special.add ) {
2260				special.add.call( elem, handleObj );
2261
2262				if ( !handleObj.handler.guid ) {
2263					handleObj.handler.guid = handler.guid;
2264				}
2265			}
2266
2267			// Add the function to the element's handler list
2268			handlers.push( handleObj );
2269
2270			// Keep track of which events have been used, for global triggering
2271			jQuery.event.global[ type ] = true;
2272		}
2273
2274		// Nullify elem to prevent memory leaks in IE
2275		elem = null;
2276	},
2277
2278	global: {},
2279
2280	// Detach an event or set of events from an element
2281	remove: function( elem, types, handler, pos ) {
2282		// don't do events on text and comment nodes
2283		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2284			return;
2285		}
2286
2287		if ( handler === false ) {
2288			handler = returnFalse;
2289		}
2290
2291		var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
2292			elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
2293			events = elemData && elemData.events;
2294
2295		if ( !elemData || !events ) {
2296			return;
2297		}
2298
2299		// types is actually an event object here
2300		if ( types && types.type ) {
2301			handler = types.handler;
2302			types = types.type;
2303		}
2304
2305		// Unbind all events for the element
2306		if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
2307			types = types || "";
2308
2309			for ( type in events ) {
2310				jQuery.event.remove( elem, type + types );
2311			}
2312
2313			return;
2314		}
2315
2316		// Handle multiple events separated by a space
2317		// jQuery(...).unbind("mouseover mouseout", fn);
2318		types = types.split(" ");
2319
2320		while ( (type = types[ i++ ]) ) {
2321			origType = type;
2322			handleObj = null;
2323			all = type.indexOf(".") < 0;
2324			namespaces = [];
2325
2326			if ( !all ) {
2327				// Namespaced event handlers
2328				namespaces = type.split(".");
2329				type = namespaces.shift();
2330
2331				namespace = new RegExp("(^|\\.)" +
2332					jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
2333			}
2334
2335			eventType = events[ type ];
2336
2337			if ( !eventType ) {
2338				continue;
2339			}
2340
2341			if ( !handler ) {
2342				for ( j = 0; j < eventType.length; j++ ) {
2343					handleObj = eventType[ j ];
2344
2345					if ( all || namespace.test( handleObj.namespace ) ) {
2346						jQuery.event.remove( elem, origType, handleObj.handler, j );
2347						eventType.splice( j--, 1 );
2348					}
2349				}
2350
2351				continue;
2352			}
2353
2354			special = jQuery.event.special[ type ] || {};
2355
2356			for ( j = pos || 0; j < eventType.length; j++ ) {
2357				handleObj = eventType[ j ];
2358
2359				if ( handler.guid === handleObj.guid ) {
2360					// remove the given handler for the given type
2361					if ( all || namespace.test( handleObj.namespace ) ) {
2362						if ( pos == null ) {
2363							eventType.splice( j--, 1 );
2364						}
2365
2366						if ( special.remove ) {
2367							special.remove.call( elem, handleObj );
2368						}
2369					}
2370
2371					if ( pos != null ) {
2372						break;
2373					}
2374				}
2375			}
2376
2377			// remove generic event handler if no more handlers exist
2378			if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
2379				if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
2380					jQuery.removeEvent( elem, type, elemData.handle );
2381				}
2382
2383				ret = null;
2384				delete events[ type ];
2385			}
2386		}
2387
2388		// Remove the expando if it's no longer used
2389		if ( jQuery.isEmptyObject( events ) ) {
2390			var handle = elemData.handle;
2391			if ( handle ) {
2392				handle.elem = null;
2393			}
2394
2395			delete elemData.events;
2396			delete elemData.handle;
2397
2398			if ( jQuery.isEmptyObject( elemData ) ) {
2399				jQuery.removeData( elem, undefined, true );
2400			}
2401		}
2402	},
2403
2404	// bubbling is internal
2405	trigger: function( event, data, elem /*, bubbling */ ) {
2406		// Event object or event type
2407		var type = event.type || event,
2408			bubbling = arguments[3];
2409
2410		if ( !bubbling ) {
2411			event = typeof event === "object" ?
2412				// jQuery.Event object
2413				event[ jQuery.expando ] ? event :
2414				// Object literal
2415				jQuery.extend( jQuery.Event(type), event ) :
2416				// Just the event type (string)
2417				jQuery.Event(type);
2418
2419			if ( type.indexOf("!") >= 0 ) {
2420				event.type = type = type.slice(0, -1);
2421				event.exclusive = true;
2422			}
2423
2424			// Handle a global trigger
2425			if ( !elem ) {
2426				// Don't bubble custom events when global (to avoid too much overhead)
2427				event.stopPropagation();
2428
2429				// Only trigger if we've ever bound an event for it
2430				if ( jQuery.event.global[ type ] ) {
2431					// XXX This code smells terrible. event.js should not be directly
2432					// inspecting the data cache
2433					jQuery.each( jQuery.cache, function() {
2434						// internalKey variable is just used to make it easier to find
2435						// and potentially change this stuff later; currently it just
2436						// points to jQuery.expando
2437						var internalKey = jQuery.expando,
2438							internalCache = this[ internalKey ];
2439						if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
2440							jQuery.event.trigger( event, data, internalCache.handle.elem );
2441						}
2442					});
2443				}
2444			}
2445
2446			// Handle triggering a single element
2447
2448			// don't do events on text and comment nodes
2449			if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
2450				return undefined;
2451			}
2452
2453			// Clean up in case it is reused
2454			event.result = undefined;
2455			event.target = elem;
2456
2457			// Clone the incoming data, if any
2458			data = jQuery.makeArray( data );
2459			data.unshift( event );
2460		}
2461
2462		event.currentTarget = elem;
2463
2464		// Trigger the event, it is assumed that "handle" is a function
2465		var handle = jQuery._data( elem, "handle" );
2466
2467		if ( handle ) {
2468			handle.apply( elem, data );
2469		}
2470
2471		var parent = elem.parentNode || elem.ownerDocument;
2472
2473		// Trigger an inline bound script
2474		try {
2475			if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) {
2476				if ( elem[ "on" + type ] && elem[ "on" + type ].apply( elem, data ) === false ) {
2477					event.result = false;

2478					event.preventDefault();
2479				}
2480			}
2481
2482		// prevent IE from throwing an error for some elements with some event types, see #3533
2483		} catch (inlineError) {}
2484
2485		if ( !event.isPropagationStopped() && parent ) {
2486			jQuery.event.trigger( event, data, parent, true );
2487
2488		} else if ( !event.isDefaultPrevented() ) {
2489			var old,
2490				target = event.target,
2491				targetType = type.replace( rnamespaces, "" ),
2492				isClick = jQuery.nodeName( target, "a" ) && targetType === "click",
2493				special = jQuery.event.special[ targetType ] || {};
2494
2495			if ( (!special._default || special._default.call( elem, event ) === false) &&
2496				!isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) {
2497
2498				try {
2499					if ( target[ targetType ] ) {
2500						// Make sure that we don't accidentally re-trigger the onFOO events
2501						old = target[ "on" + targetType ];
2502
2503						if ( old ) {
2504							target[ "on" + targetType ] = null;
2505						}
2506
2507						jQuery.event.triggered = true;
2508						target[ targetType ]();
2509					}
2510
2511				// prevent IE from throwing an error for some elements with some event types, see #3533
2512				} catch (triggerError) {}
2513
2514				if ( old ) {
2515					target[ "on" + targetType ] = old;
2516				}
2517
2518				jQuery.event.triggered = false;
2519			}
2520		}
2521	},
2522
2523	handle: function( event ) {
2524		var all, handlers, namespaces, namespace_re, events,
2525			namespace_sort = [],
2526			args = jQuery.makeArray( arguments );
2527
2528		event = args[0] = jQuery.event.fix( event || window.event );
2529		event.currentTarget = this;
2530
2531		// Namespaced event handlers
2532		all = event.type.indexOf(".") < 0 && !event.exclusive;
2533
2534		if ( !all ) {
2535			namespaces = event.type.split(".");
2536			event.type = namespaces.shift();
2537			namespace_sort = namespaces.slice(0).sort();
2538			namespace_re = new RegExp("(^|\\.)" + namespace_sort.join("\\.(?:.*\\.)?") + "(\\.|$)");
2539		}
2540
2541		event.namespace = event.namespace || namespace_sort.join(".");
2542
2543		events = jQuery._data(this, "events");
2544
2545		handlers = (events || {})[ event.type ];
2546
2547		if ( events && handlers ) {
2548			// Clone the handlers to prevent manipulation
2549			handlers = handlers.slice(0);
2550
2551			for ( var j = 0, l = handlers.length; j < l; j++ ) {
2552				var handleObj = handlers[ j ];
2553
2554				// Filter the functions by class
2555				if ( all || namespace_re.test( handleObj.namespace ) ) {
2556					// Pass in a reference to the handler function itself
2557					// So that we can later remove it
2558					event.handler = handleObj.handler;
2559					event.data = handleObj.data;
2560					event.handleObj = handleObj;
2561
2562					var ret = handleObj.handler.apply( this, args );
2563
2564					if ( ret !== undefined ) {
2565						event.result = ret;
2566						if ( ret === false ) {
2567							event.preventDefault();
2568							event.stopPropagation();
2569						}
2570					}
2571
2572					if ( event.isImmediatePropagationStopped() ) {
2573						break;
2574					}
2575				}
2576			}
2577		}
2578
2579		return event.result;
2580	},
2581
2582	props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
2583
2584	fix: function( event ) {
2585		if ( event[ jQuery.expando ] ) {
2586			return event;
2587		}
2588
2589		// store a copy of the original event object
2590		// and "clone" to set read-only properties
2591		var originalEvent = event;
2592		event = jQuery.Event( originalEvent );
2593
2594		for ( var i = this.props.length, prop; i; ) {
2595			prop = this.props[ --i ];
2596			event[ prop ] = originalEvent[ prop ];
2597		}
2598
2599		// Fix target property, if necessary
2600		if ( !event.target ) {
2601			// Fixes #1925 where srcElement might not be defined either
2602			event.target = event.srcElement || document;
2603		}
2604
2605		// check if target is a textnode (safari)
2606		if ( event.target.nodeType === 3 ) {
2607			event.target = event.target.parentNode;
2608		}
2609
2610		// Add relatedTarget, if necessary
2611		if ( !event.relatedTarget && event.fromElement ) {
2612			event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
2613		}
2614
2615		// Calculate pageX/Y if missing and clientX/Y available
2616		if ( event.pageX == null && event.clientX != null ) {
2617			var doc = document.documentElement,
2618				body = document.body;
2619
2620			event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
2621			event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
2622		}
2623
2624		// Add which for key events
2625		if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
2626			event.which = event.charCode != null ? event.charCode : event.keyCode;
2627		}
2628
2629		// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2630		if ( !event.metaKey && event.ctrlKey ) {
2631			event.metaKey = event.ctrlKey;
2632		}
2633
2634		// Add which for click: 1 === left; 2 === middle; 3 === right
2635		// Note: button is not normalized, so don't use it
2636		if ( !event.which && event.button !== undefined ) {
2637			event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2638		}
2639
2640		return event;
2641	},
2642
2643	// Deprecated, use jQuery.guid instead
2644	guid: 1E8,
2645
2646	// Deprecated, use jQuery.proxy instead
2647	proxy: jQuery.proxy,
2648
2649	special: {
2650		ready: {
2651			// Make sure the ready event is setup
2652			setup: jQuery.bindReady,
2653			teardown: jQuery.noop
2654		},
2655
2656		live: {
2657			add: function( handleObj ) {
2658				jQuery.event.add( this,
2659					liveConvert( handleObj.origType, handleObj.selector ),
2660					jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
2661			},
2662
2663			remove: function( handleObj ) {
2664				jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
2665			}
2666		},
2667
2668		beforeunload: {
2669			setup: function( data, namespaces, eventHandle ) {
2670				// We only want to do this special case on windows
2671				if ( jQuery.isWindow( this ) ) {
2672					this.onbeforeunload = eventHandle;
2673				}
2674			},
2675
2676			teardown: function( namespaces, eventHandle ) {
2677				if ( this.onbeforeunload === eventHandle ) {
2678					this.onbeforeunload = null;
2679				}
2680			}
2681		}
2682	}
2683};
2684
2685jQuery.removeEvent = document.removeEventListener ?
2686	function( elem, type, handle ) {
2687		if ( elem.removeEventListener ) {
2688			elem.removeEventListener( type, handle, false );
2689		}
2690	} :
2691	function( elem, type, handle ) {
2692		if ( elem.detachEvent ) {
2693			elem.detachEvent( "on" + type, handle );
2694		}
2695	};
2696
2697jQuery.Event = function( src ) {
2698	// Allow instantiation without the 'new' keyword
2699	if ( !this.preventDefault ) {
2700		return new jQuery.Event( src );
2701	}
2702
2703	// Event object
2704	if ( src && src.type ) {
2705		this.originalEvent = src;
2706		this.type = src.type;
2707
2708		// Events bubbling up the document may have been marked as prevented
2709		// by a handler lower down the tree; reflect the correct value.
2710		this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
2711			src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
2712
2713	// Event type
2714	} else {
2715		this.type = src;
2716	}
2717
2718	// timeStamp is buggy for some events on Firefox(#3843)
2719	// So we won't rely on the native value
2720	this.timeStamp = jQuery.now();
2721
2722	// Mark it as fixed
2723	this[ jQuery.expando ] = true;
2724};
2725
2726function returnFalse() {
2727	return false;