https://www.turquieeuropeenne.eu/prive/javascript/jquery.js

151					// If a single string is passed in and it's a single tag
152					// just do a createElement and skip the rest
153					ret = rsingleTag.exec( selector );
154
155					if ( ret ) {
156						if ( jQuery.isPlainObject( context ) ) {
157							selector = [ document.createElement( ret[1] ) ];
158							jQuery.fn.attr.call( selector, context, true );
159
160						} else {
161							selector = [ doc.createElement( ret[1] ) ];
162						}
163
164					} else {
165						ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
166						selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes;
167					}
168
169					return jQuery.merge( this, selector );
170
171				// HANDLE: $("#id")
172				} else {
173					elem = document.getElementById( match[2] );
174
175					// Check parentNode to catch when Blackberry 4.6 returns
176					// nodes that are no longer in the document #6963
177					if ( elem && elem.parentNode ) {
178						// Handle the case where IE and Opera return items
179						// by name instead of ID
180						if ( elem.id !== match[2] ) {
181							return rootjQuery.find( selector );
182						}
183
184						// Otherwise, we inject the element directly into the jQuery object
185						this.length = 1;
186						this[0] = elem;
187					}
188
189					this.context = document;
190					this.selector = selector;
191					return this;
192				}
193
194			// HANDLE: $(expr, $(...))
195			} else if ( !context || context.jquery ) {
196				return ( context || rootjQuery ).find( selector );
197
198			// HANDLE: $(expr, context)
199			// (which is just equivalent to: $(context).find(expr)
200			} else {
201				return this.constructor( context ).find( selector );
202			}
203
204		// HANDLE: $(function)
205		// Shortcut for document ready
206		} else if ( jQuery.isFunction( selector ) ) {
207			return rootjQuery.ready( selector );
208		}
209
210		if ( selector.selector !== undefined ) {
211			this.selector = selector.selector;
212			this.context = selector.context;
213		}
214
215		return jQuery.makeArray( selector, this );
216	},
217
218	// Start with an empty selector
219	selector: "",
220
221	// The current version of jQuery being used
222	jquery: "1.7.2",
223
224	// The default length of a jQuery object is 0
225	length: 0,
226
227	// The number of elements contained in the matched element set
228	size: function() {
229		return this.length;
230	},
231
232	toArray: function() {
233		return slice.call( this, 0 );
234	},
235
236	// Get the Nth element in the matched element set OR
237	// Get the whole matched element set as a clean array
238	get: function( num ) {
239		return num == null ?
240
241			// Return a 'clean' array
242			this.toArray() :
243
244			// Return just the object
245			( num < 0 ? this[ this.length + num ] : this[ num ] );
246	},
247
248	// Take an array of elements and push it onto the stack
249	// (returning the new matched element set)
250	pushStack: function( elems, name, selector ) {
251		// Build a new jQuery matched element set
252		var ret = this.constructor();
253
254		if ( jQuery.isArray( elems ) ) {
255			push.apply( ret, elems );
256
257		} else {
258			jQuery.merge( ret, elems );
259		}
260
261		// Add the old object onto the stack (as a reference)
262		ret.prevObject = this;
263
264		ret.context = this.context;
265
266		if ( name === "find" ) {
267			ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
268		} else if ( name ) {
269			ret.selector = this.selector + "." + name + "(" + selector + ")";
270		}
271
272		// Return the newly-formed element set
273		return ret;
274	},
275
276	// Execute a callback for every element in the matched set.
277	// (You can seed the arguments with an array of args, but this is
278	// only used internally.)
279	each: function( callback, args ) {
280		return jQuery.each( this, callback, args );
281	},
282
283	ready: function( fn ) {
284		// Attach the listeners
285		jQuery.bindReady();
286
287		// Add the callback
288		readyList.add( fn );
289
290		return this;
291	},
292
293	eq: function( i ) {
294		i = +i;
295		return i === -1 ?
296			this.slice( i ) :
297			this.slice( i, i + 1 );
298	},
299
300	first: function() {
301		return this.eq( 0 );
302	},
303
304	last: function() {
305		return this.eq( -1 );
306	},
307
308	slice: function() {
309		return this.pushStack( slice.apply( this, arguments ),
310			"slice", slice.call(arguments).join(",") );
311	},
312
313	map: function( callback ) {
314		return this.pushStack( jQuery.map(this, function( elem, i ) {
315			return callback.call( elem, i, elem );
316		}));
317	},
318
319	end: function() {
320		return this.prevObject || this.constructor(null);
321	},
322
323	// For internal use only.
324	// Behaves like an Array's method, not like a jQuery method.
325	push: push,
326	sort: [].sort,
327	splice: [].splice
328};
329
330// Give the init function the jQuery prototype for later instantiation
331jQuery.fn.init.prototype = jQuery.fn;
332
333jQuery.extend = jQuery.fn.extend = function() {
334	var options, name, src, copy, copyIsArray, clone,
335		target = arguments[0] || {},
336		i = 1,
337		length = arguments.length,
338		deep = false;

339
340	// Handle a deep copy situation
341	if ( typeof target === "boolean" ) {
342		deep = target;
343		target = arguments[1] || {};
344		// skip the boolean and the target
345		i = 2;
346	}
347
348	// Handle case when target is a string or something (possible in deep copy)
349	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
350		target = {};
351	}
352
353	// extend jQuery itself if only one argument is passed
354	if ( length === i ) {
355		target = this;
356		--i;
357	}
358
359	for ( ; i < length; i++ ) {
360		// Only deal with non-null/undefined values
361		if ( (options = arguments[ i ]) != null ) {
362			// Extend the base object
363			for ( name in options ) {
364				src = target[ name ];
365				copy = options[ name ];
366
367				// Prevent never-ending loop
368				if ( target === copy ) {
369					continue;
370				}
371
372				// Recurse if we're merging plain objects or arrays
373				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
374					if ( copyIsArray ) {
375						copyIsArray = false;
376						clone = src && jQuery.isArray(src) ? src : [];
377
378					} else {
379						clone = src && jQuery.isPlainObject(src) ? src : {};
380					}
381
382					// Never move original objects, clone them
383					target[ name ] = jQuery.extend( deep, clone, copy );
384
385				// Don't bring in undefined values
386				} else if ( copy !== undefined ) {
387					target[ name ] = copy;
388				}
389			}
390		}
391	}
392
393	// Return the modified object
394	return target;
395};
396
397jQuery.extend({
398	noConflict: function( deep ) {
399		if ( window.$ === jQuery ) {
400			window.$ = _$;
401		}
402
403		if ( deep && window.jQuery === jQuery ) {
404			window.jQuery = _jQuery;
405		}
406
407		return jQuery;
408	},
409
410	// Is the DOM ready to be used? Set to true once it occurs.
411	isReady: false,
412
413	// A counter to track how many items to wait for before
414	// the ready event fires. See #6781
415	readyWait: 1,
416
417	// Hold (or release) the ready event
418	holdReady: function( hold ) {
419		if ( hold ) {
420			jQuery.readyWait++;
421		} else {
422			jQuery.ready( true );
423		}
424	},
425
426	// Handle when the DOM is ready
427	ready: function( wait ) {
428		// Either a released hold or an DOMready/load event and not yet ready
429		if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
430			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
431			if ( !document.body ) {
432				return setTimeout( jQuery.ready, 1 );
433			}
434
435			// Remember that the DOM is ready
436			jQuery.isReady = true;
437
438			// If a normal DOM Ready event fired, decrement, and wait if need be
439			if ( wait !== true && --jQuery.readyWait > 0 ) {
440				return;
441			}
442
443			// If there are functions bound, to execute
444			readyList.fireWith( document, [ jQuery ] );
445
446			// Trigger any bound ready events
447			if ( jQuery.fn.trigger ) {
448				jQuery( document ).trigger( "ready" ).off( "ready" );
449			}
450		}
451	},
452
453	bindReady: function() {
454		if ( readyList ) {
455			return;
456		}
457
458		readyList = jQuery.Callbacks( "once memory" );
459
460		// Catch cases where $(document).ready() is called after the
461		// browser event has already occurred.
462		if ( document.readyState === "complete" ) {
463			// Handle it asynchronously to allow scripts the opportunity to delay ready
464			return setTimeout( jQuery.ready, 1 );
465		}
466
467		// Mozilla, Opera and webkit nightlies currently support this event
468		if ( document.addEventListener ) {
469			// Use the handy event callback
470			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
471
472			// A fallback to window.onload, that will always work
473			window.addEventListener( "load", jQuery.ready, false );
474
475		// If IE event model is used
476		} else if ( document.attachEvent ) {
477			// ensure firing before onload,
478			// maybe late but safe also for iframes
479			document.attachEvent( "onreadystatechange", DOMContentLoaded );
480
481			// A fallback to window.onload, that will always work
482			window.attachEvent( "onload", jQuery.ready );
483
484			// If IE and not a frame
485			// continually check to see if the document is ready
486			var toplevel = false;
487
488			try {
489				toplevel = window.frameElement == null;
490			} catch(e) {}
491
492			if ( document.documentElement.doScroll && toplevel ) {
493				doScrollCheck();
494			}
495		}
496	},
497
498	// See test/unit/core.js for details concerning isFunction.
499	// Since version 1.3, DOM methods and functions like alert
500	// aren't supported. They return false on IE (#2968).
501	isFunction: function( obj ) {
502		return jQuery.type(obj) === "function";
503	},
504
505	isArray: Array.isArray || function( obj ) {
506		return jQuery.type(obj) === "array";
507	},
508
509	isWindow: function( obj ) {
510		return obj != null && obj == obj.window;
511	},
512
513	isNumeric: function( obj ) {
514		return !isNaN( parseFloat(obj) ) && isFinite( obj );
515	},
516
517	type: function( obj ) {
518		return obj == null ?
519			String( obj ) :
520			class2type[ toString.call(obj) ] || "object";
521	},
522
523	isPlainObject: function( obj ) {
524		// Must be an Object.
525		// Because of IE, we also have to check the presence of the constructor property.
526		// Make sure that DOM nodes and window objects don't pass through, as well
527		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
528			return false;
529		}
530
531		try {
532			// Not own constructor property must be Object
533			if ( obj.constructor &&
534				!hasOwn.call(obj, "constructor") &&
535				!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
536				return false;
537			}
538		} catch ( e ) {
539			// IE8,9 Will throw exceptions on certain host objects #9897
540			return false;
541		}
542
543		// Own properties are enumerated firstly, so to speed up,
544		// if last one is own, then all properties are own.
545
546		var key;
547		for ( key in obj ) {}
548
549		return key === undefined || hasOwn.call( obj, key );
550	},
551
552	isEmptyObject: function( obj ) {
553		for ( var name in obj ) {
554			return false;
555		}
556		return true;
557	},
558
559	error: function( msg ) {
560		throw new Error( msg );
561	},
562
563	parseJSON: function( data ) {
564		if ( typeof data !== "string" || !data ) {
565			return null;
566		}
567
568		// Make sure leading/trailing whitespace is removed (IE can't handle it)
569		data = jQuery.trim( data );
570
571		// Attempt to parse using the native JSON parser first
572		if ( window.JSON && window.JSON.parse ) {
573			return window.JSON.parse( data );
574		}
575
576		// Make sure the incoming data is actual JSON
577		// Logic borrowed from http://json.org/json2.js
578		if ( rvalidchars.test( data.replace( rvalidescape, "@" )
579			.replace( rvalidtokens, "]" )
580			.replace( rvalidbraces, "")) ) {
581
582			return ( new Function( "return " + data ) )();
583
584		}
585		jQuery.error( "Invalid JSON: " + data );
586	},
587
588	// Cross-browser xml parsing
589	parseXML: function( data ) {
590		if ( typeof data !== "string" || !data ) {
591			return null;
592		}
593		var xml, tmp;
594		try {
595			if ( window.DOMParser ) { // Standard
596				tmp = new DOMParser();
597				xml = tmp.parseFromString( data , "text/xml" );
598			} else { // IE
599				xml = new ActiveXObject( "Microsoft.XMLDOM" );
600				xml.async = "false";
601				xml.loadXML( data );
602			}
603		} catch( e ) {
604			xml = undefined;
605		}
606		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
607			jQuery.error( "Invalid XML: " + data );
608		}
609		return xml;
610	},
611
612	noop: function() {},
613
614	// Evaluates a script in a global context
615	// Workarounds based on findings by Jim Driscoll
616	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
617	globalEval: function( data ) {
618		if ( data && rnotwhite.test( data ) ) {
619			// We use execScript on Internet Explorer
620			// We use an anonymous function so that context is window
621			// rather than jQuery in Firefox
622			( window.execScript || function( data ) {
623				window[ "eval" ].call( window, data );
624			} )( data );
625		}
626	},
627
628	// Convert dashed to camelCase; used by the css and data modules
629	// Microsoft forgot to hump their vendor prefix (#9572)
630	camelCase: function( string ) {
631		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
632	},
633
634	nodeName: function( elem, name ) {
635		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
636	},
637
638	// args is for internal usage only
639	each: function( object, callback, args ) {
640		var name, i = 0,
641			length = object.length,
642			isObj = length === undefined || jQuery.isFunction( object );
643
644		if ( args ) {
645			if ( isObj ) {
646				for ( name in object ) {
647					if ( callback.apply( object[ name ], args ) === false ) {
648						break;
649					}
650				}
651			} else {
652				for ( ; i < length; ) {
653					if ( callback.apply( object[ i++ ], args ) === false ) {
654						break;
655					}
656				}
657			}
658
659		// A special, fast, case for the most common use of each
660		} else {
661			if ( isObj ) {
662				for ( name in object ) {
663					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
664						break;
665					}
666				}
667			} else {
668				for ( ; i < length; ) {
669					if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
670						break;
671					}
672				}
673			}
674		}
675
676		return object;
677	},
678
679	// Use native String.trim function wherever possible
680	trim: trim ?
681		function( text ) {
682			return text == null ?
683				"" :
684				trim.call( text );
685		} :
686
687		// Otherwise use our own trimming functionality
688		function( text ) {
689			return text == null ?
690				"" :
691				text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
692		},
693
694	// results is for internal usage only
695	makeArray: function( array, results ) {
696		var ret = results || [];
697
698		if ( array != null ) {
699			// The window, strings (and functions) also have 'length'
700			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
701			var type = jQuery.type( array );
702
703			if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
704				push.call( ret, array );
705			} else {
706				jQuery.merge( ret, array );
707			}
708		}
709
710		return ret;
711	},
712
713	inArray: function( elem, array, i ) {
714		var len;
715
716		if ( array ) {
717			if ( indexOf ) {
718				return indexOf.call( array, elem, i );
719			}
720
721			len = array.length;
722			i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
723
724			for ( ; i < len; i++ ) {
725				// Skip accessing in sparse arrays
726				if ( i in array && array[ i ] === elem ) {
727					return i;
728				}
729			}
730		}
731
732		return -1;
733	},
734
735	merge: function( first, second ) {
736		var i = first.length,
737			j = 0;
738
739		if ( typeof second.length === "number" ) {
740			for ( var l = second.length; j < l; j++ ) {
741				first[ i++ ] = second[ j ];
742			}
743
744		} else {
745			while ( second[j] !== undefined ) {
746				first[ i++ ] = second[ j++ ];
747			}
748		}
749
750		first.length = i;
751
752		return first;
753	},
754
755	grep: function( elems, callback, inv ) {
756		var ret = [], retVal;
757		inv = !!inv;
758
759		// Go through the array, only saving the items
760		// that pass the validator function
761		for ( var i = 0, length = elems.length; i < length; i++ ) {
762			retVal = !!callback( elems[ i ], i );
763			if ( inv !== retVal ) {
764				ret.push( elems[ i ] );
765			}
766		}
767
768		return ret;
769	},
770
771	// arg is for internal usage only
772	map: function( elems, callback, arg ) {
773		var value, key, ret = [],
774			i = 0,
775			length = elems.length,
776			// jquery objects are treated as arrays
777			isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
778
779		// Go through the array, translating each of the items to their
780		if ( isArray ) {
781			for ( ; i < length; i++ ) {
782				value = callback( elems[ i ], i, arg );
783
784				if ( value != null ) {
785					ret[ ret.length ] = value;
786				}
787			}
788
789		// Go through every key on the object,
790		} else {
791			for ( key in elems ) {
792				value = callback( elems[ key ], key, arg );
793
794				if ( value != null ) {
795					ret[ ret.length ] = value;
796				}
797			}
798		}
799
800		// Flatten any nested arrays
801		return ret.concat.apply( [], ret );
802	},
803
804	// A global GUID counter for objects
805	guid: 1,
806
807	// Bind a function to a context, optionally partially applying any
808	// arguments.
809	proxy: function( fn, context ) {
810		if ( typeof context === "string" ) {
811			var tmp = fn[ context ];
812			context = fn;
813			fn = tmp;
814		}
815
816		// Quick check to determine if target is callable, in the spec
817		// this throws a TypeError, but we will just return undefined.
818		if ( !jQuery.isFunction( fn ) ) {
819			return undefined;
820		}
821
822		// Simulated bind
823		var args = slice.call( arguments, 2 ),
824			proxy = function() {
825				return fn.apply( context, args.concat( slice.call( arguments ) ) );
826			};
827
828		// Set the guid of unique handler to the same of original handler, so it can be removed
829		proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
830
831		return proxy;
832	},
833
834	// Mutifunctional method to get and set values to a collection
835	// The value/s can optionally be executed if it's a function
836	access: function( elems, fn, key, value, chainable, emptyGet, pass ) {
837		var exec,
838			bulk = key == null,
839			i = 0,
840			length = elems.length;
841
842		// Sets many values
843		if ( key && typeof key === "object" ) {
844			for ( i in key ) {
845				jQuery.access( elems, fn, i, key[i], 1, emptyGet, value );
846			}
847			chainable = 1;
848
849		// Sets one value
850		} else if ( value !== undefined ) {
851			// Optionally, function values get executed if exec is true
852			exec = pass === undefined && jQuery.isFunction( value );
853
854			if ( bulk ) {
855				// Bulk operations only iterate when executing function values
856				if ( exec ) {
857					exec = fn;
858					fn = function( elem, key, value ) {
859						return exec.call( jQuery( elem ), value );
860					};
861
862				// Otherwise they run against the entire set
863				} else {
864					fn.call( elems, value );
865					fn = null;
866				}
867			}
868
869			if ( fn ) {
870				for (; i < length; i++ ) {
871					fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
872				}
873			}
874
875			chainable = 1;
876		}
877
878		return chainable ?
879			elems :
880
881			// Gets
882			bulk ?
883				fn.call( elems ) :
884				length ? fn( elems[0], key ) : emptyGet;
885	},
886
887	now: function() {
888		return ( new Date() ).getTime();
889	},
890
891	// Use of jQuery.browser is frowned upon.
892	// More details: http://docs.jquery.com/Utilities/jQuery.browser
893	uaMatch: function( ua ) {
894		ua = ua.toLowerCase();
895
896		var match = rwebkit.exec( ua ) ||
897			ropera.exec( ua ) ||
898			rmsie.exec( ua ) ||
899			ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
900			[];
901
902		return { browser: match[1] || "", version: match[2] || "0" };
903	},
904
905	sub: function() {
906		function jQuerySub( selector, context ) {
907			return new jQuerySub.fn.init( selector, context );
908		}
909		jQuery.extend( true, jQuerySub, this );
910		jQuerySub.superclass = this;
911		jQuerySub.fn = jQuerySub.prototype = this();
912		jQuerySub.fn.constructor = jQuerySub;
913		jQuerySub.sub = this.sub;
914		jQuerySub.fn.init = function init( selector, context ) {
915			if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
916				context = jQuerySub( context );
917			}
918
919			return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
920		};
921		jQuerySub.fn.init.prototype = jQuerySub.fn;
922		var rootjQuerySub = jQuerySub(document);
923		return jQuerySub;
924	},
925
926	browser: {}
927});
928
929// Populate the class2type map
930jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
931	class2type[ "[object " + name + "]" ] = name.toLowerCase();
932});
933
934browserMatch = jQuery.uaMatch( userAgent );
935if ( browserMatch.browser ) {
936	jQuery.browser[ browserMatch.browser ] = true;
937	jQuery.browser.version = browserMatch.version;
938}
939
940// Deprecated, use jQuery.browser.webkit instead
941if ( jQuery.browser.webkit ) {
942	jQuery.browser.safari = true;
943}
944

1388<input type='checkbox'/>";
1389
1390	all = div.getElementsByTagName( "*" );
1391	a = div.getElementsByTagName( "a" )[ 0 ];
1392
1393	// Can't get basic test support
1394	if ( !all || !all.length || !a ) {
1395		return {};
1396	}
1397
1398	// First batch of supports tests
1399	select = document.createElement( "select" );
1400	opt = select.appendChild( document.createElement("option") );
1401	input = div.getElementsByTagName( "input" )[ 0 ];
1402
1403	support = {
1404		// IE strips leading whitespace when .innerHTML is used
1405		leadingWhitespace: ( div.firstChild.nodeType === 3 ),
1406
1407		// Make sure that tbody elements aren't automatically inserted
1408		// IE will insert them into empty tables
1409		tbody: !div.getElementsByTagName("tbody").length,
1410
1411		// Make sure that link elements get serialized correctly by innerHTML
1412		// This requires a wrapper element in IE
1413		htmlSerialize: !!div.getElementsByTagName("link").length,
1414
1415		// Get the style information from getAttribute
1416		// (IE uses .cssText instead)
1417		style: /top/.test( a.getAttribute("style") ),
1418
1419		// Make sure that URLs aren't manipulated
1420		// (IE normalizes it by default)
1421		hrefNormalized: ( a.getAttribute("href") === "/a" ),
1422
1423		// Make sure that element opacity exists
1424		// (IE uses filter instead)
1425		// Use a regex to work around a WebKit issue. See #5145
1426		opacity: /^0.55/.test( a.style.opacity ),
1427
1428		// Verify style float existence
1429		// (IE uses styleFloat instead of cssFloat)
1430		cssFloat: !!a.style.cssFloat,
1431
1432		// Make sure that if no value is specified for a checkbox
1433		// that it defaults to "on".
1434		// (WebKit defaults to "" instead)
1435		checkOn: ( input.value === "on" ),
1436
1437		// Make sure that a selected-by-default option has a working selected property.
1438		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1439		optSelected: opt.selected,
1440
1441		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1442		getSetAttribute: div.className !== "t",
1443
1444		// Tests for enctype support on a form(#6743)
1445		enctype: !!document.createElement("form").enctype,
1446
1447		// Makes sure cloning an html5 element does not cause problems
1448		// Where outerHTML is undefined, this still works
1449		html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
1450
1451		// Will be defined later
1452		submitBubbles: true,
1453		changeBubbles: true,
1454		focusinBubbles: false,
1455		deleteExpando: true,
1456		noCloneEvent: true,
1457		inlineBlockNeedsLayout: false,
1458		shrinkWrapBlocks: false,
1459		reliableMarginRight: true,
1460		pixelMargin: true
1461	};
1462
1463	// jQuery.boxModel DEPRECATED in 1.3, use jQuery.support.boxModel instead
1464	jQuery.boxModel = support.boxModel = (document.compatMode === "CSS1Compat");
1465
1466	// Make sure checked status is properly cloned
1467	input.checked = true;
1468	support.noCloneChecked = input.cloneNode( true ).checked;
1469
1470	// Make sure that the options inside disabled selects aren't marked as disabled
1471	// (WebKit marks them as disabled)
1472	select.disabled = true;
1473	support.optDisabled = !opt.disabled;
1474
1475	// Test to see if it's possible to delete an expando from an element
1476	// Fails in Internet Explorer
1477	try {
1478		delete div.test;
1479	} catch( e ) {
1480		support.deleteExpando = false;
1481	}
1482
1483	if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1484		div.attachEvent( "onclick", function() {
1485			// Cloning a node shouldn't copy over any
1486			// bound event handlers (IE does this)
1487			support.noCloneEvent = false;
1488		});
1489		div.cloneNode( true ).fireEvent( "onclick" );
1490	}
1491
1492	// Check if a radio maintains its value
1493	// after being appended to the DOM
1494	input = document.createElement("input");
1495	input.value = "t";
1496	input.setAttribute("type", "radio");
1497	support.radioValue = input.value === "t";
1498
1499	input.setAttribute("checked", "checked");
1500
1501	// #11217 - WebKit loses check when the name is after the checked attribute
1502	input.setAttribute( "name", "t" );
1503
1504	div.appendChild( input );
1505	fragment = document.createDocumentFragment();
1506	fragment.appendChild( div.lastChild );
1507
1508	// WebKit doesn't clone checked state correctly in fragments
1509	support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
1510
1511	// Check if a disconnected checkbox will retain its checked
1512	// value of true after appended to the DOM (IE6/7)

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

2156			this :
2157			this.each(function() {
2158				var queue = jQuery.queue( this, type, data );
2159
2160				if ( type === "fx" && queue[0] !== "inprogress" ) {
2161					jQuery.dequeue( this, type );
2162				}
2163			});
2164	},
2165	dequeue: function( type ) {
2166		return this.each(function() {
2167			jQuery.dequeue( this, type );
2168		});
2169	},
2170	// Based off of the plugin by Clint Helfers, with permission.
2171	// http://blindsignals.com/index.php/2009/07/jquery-delay/
2172	delay: function( time, type ) {
2173		time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
2174		type = type || "fx";
2175
2176		return this.queue( type, function( next, hooks ) {
2177			var timeout = setTimeout( next, time );
2178			hooks.stop = function() {
2179				clearTimeout( timeout );
2180			};
2181		});
2182	},
2183	clearQueue: function( type ) {
2184		return this.queue( type || "fx", [] );
2185	},
2186	// Get a promise resolved when queues of a certain type
2187	// are emptied (fx is the type by default)
2188	promise: function( type, object ) {
2189		if ( typeof type !== "string" ) {
2190			object = type;
2191			type = undefined;
2192		}
2193		type = type || "fx";
2194		var defer = jQuery.Deferred(),
2195			elements = this,
2196			i = elements.length,
2197			count = 1,
2198			deferDataKey = type + "defer",
2199			queueDataKey = type + "queue",
2200			markDataKey = type + "mark",
2201			tmp;
2202		function resolve() {
2203			if ( !( --count ) ) {
2204				defer.resolveWith( elements, [ elements ] );
2205			}
2206		}
2207		while( i-- ) {
2208			if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
2209					( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
2210						jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
2211					jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) {
2212				count++;
2213				tmp.add( resolve );
2214			}
2215		}
2216		resolve();
2217		return defer.promise( object );
2218	}
2219});
2220
2221
2222
2223
2224var rclass = /[\n\t\r]/g,
2225	rspace = /\s+/,
2226	rreturn = /\r/g,
2227	rtype = /^(?:button|input)$/i,
2228	rfocusable = /^(?:button|input|object|select|textarea)$/i,
2229	rclickable = /^a(?:rea)?$/i,
2230	rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
2231	getSetAttribute = jQuery.support.getSetAttribute,
2232	nodeHook, boolHook, fixSpecified;
2233
2234jQuery.fn.extend({
2235	attr: function( name, value ) {
2236		return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
2237	},
2238
2239	removeAttr: function( name ) {
2240		return this.each(function() {
2241			jQuery.removeAttr( this, name );
2242		});
2243	},
2244
2245	prop: function( name, value ) {
2246		return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
2247	},
2248
2249	removeProp: function( name ) {
2250		name = jQuery.propFix[ name ] || name;
2251		return this.each(function() {
2252			// try/catch handles cases where IE balks (such as removing a property on window)
2253			try {
2254				this[ name ] = undefined;
2255				delete this[ name ];
2256			} catch( e ) {}
2257		});
2258	},
2259
2260	addClass: function( value ) {
2261		var classNames, i, l, elem,
2262			setClass, c, cl;
2263
2264		if ( jQuery.isFunction( value ) ) {
2265			return this.each(function( j ) {
2266				jQuery( this ).addClass( value.call(this, j, this.className) );
2267			});
2268		}
2269
2270		if ( value && typeof value === "string" ) {
2271			classNames = value.split( rspace );
2272
2273			for ( i = 0, l = this.length; i < l; i++ ) {
2274				elem = this[ i ];
2275
2276				if ( elem.nodeType === 1 ) {
2277					if ( !elem.className && classNames.length === 1 ) {
2278						elem.className = value;
2279
2280					} else {
2281						setClass = " " + elem.className + " ";
2282
2283						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2284							if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
2285								setClass += classNames[ c ] + " ";
2286							}
2287						}
2288						elem.className = jQuery.trim( setClass );
2289					}
2290				}
2291			}
2292		}
2293
2294		return this;
2295	},
2296
2297	removeClass: function( value ) {
2298		var classNames, i, l, elem, className, c, cl;
2299
2300		if ( jQuery.isFunction( value ) ) {
2301			return this.each(function( j ) {
2302				jQuery( this ).removeClass( value.call(this, j, this.className) );
2303			});
2304		}
2305
2306		if ( (value && typeof value === "string") || value === undefined ) {
2307			classNames = ( value || "" ).split( rspace );
2308
2309			for ( i = 0, l = this.length; i < l; i++ ) {
2310				elem = this[ i ];
2311
2312				if ( elem.nodeType === 1 && elem.className ) {
2313					if ( value ) {
2314						className = (" " + elem.className + " ").replace( rclass, " " );
2315						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2316							className = className.replace(" " + classNames[ c ] + " ", " ");
2317						}
2318						elem.className = jQuery.trim( className );
2319
2320					} else {
2321						elem.className = "";
2322					}
2323				}
2324			}
2325		}
2326
2327		return this;
2328	},
2329
2330	toggleClass: function( value, stateVal ) {
2331		var type = typeof value,
2332			isBool = typeof stateVal === "boolean";
2333
2334		if ( jQuery.isFunction( value ) ) {
2335			return this.each(function( i ) {
2336				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
2337			});
2338		}
2339
2340		return this.each(function() {
2341			if ( type === "string" ) {
2342				// toggle individual class names
2343				var className,
2344					i = 0,
2345					self = jQuery( this ),
2346					state = stateVal,
2347					classNames = value.split( rspace );
2348
2349				while ( (className = classNames[ i++ ]) ) {
2350					// check each className given, space seperated list
2351					state = isBool ? state : !self.hasClass( className );
2352					self[ state ? "addClass" : "removeClass" ]( className );
2353				}
2354
2355			} else if ( type === "undefined" || type === "boolean" ) {
2356				if ( this.className ) {
2357					// store className if set
2358					jQuery._data( this, "__className__", this.className );
2359				}
2360
2361				// toggle whole className
2362				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2363			}
2364		});
2365	},
2366
2367	hasClass: function( selector ) {
2368		var className = " " + selector + " ",
2369			i = 0,
2370			l = this.length;
2371		for ( ; i < l; i++ ) {
2372			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2373				return true;
2374			}
2375		}
2376
2377		return false;
2378	},
2379
2380	val: function( value ) {
2381		var hooks, ret, isFunction,
2382			elem = this[0];
2383
2384		if ( !arguments.length ) {
2385			if ( elem ) {
2386				hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
2387
2388				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2389					return ret;
2390				}
2391
2392				ret = elem.value;
2393
2394				return typeof ret === "string" ?
2395					// handle most common string cases
2396					ret.replace(rreturn, "") :
2397					// handle cases where value is null/undef or number
2398					ret == null ? "" : ret;
2399			}
2400
2401			return;
2402		}
2403
2404		isFunction = jQuery.isFunction( value );
2405
2406		return this.each(function( i ) {
2407			var self = jQuery(this), val;
2408
2409			if ( this.nodeType !== 1 ) {
2410				return;
2411			}
2412
2413			if ( isFunction ) {
2414				val = value.call( this, i, self.val() );
2415			} else {
2416				val = value;
2417			}
2418
2419			// Treat null/undefined as ""; convert numbers to string
2420			if ( val == null ) {
2421				val = "";
2422			} else if ( typeof val === "number" ) {
2423				val += "";
2424			} else if ( jQuery.isArray( val ) ) {
2425				val = jQuery.map(val, function ( value ) {
2426					return value == null ? "" : value + "";
2427				});
2428			}
2429
2430			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
2431
2432			// If set returns undefined, fall back to normal setting
2433			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
2434				this.value = val;
2435			}
2436		});
2437	}
2438});
2439
2440jQuery.extend({
2441	valHooks: {
2442		option: {
2443			get: function( elem ) {
2444				// attributes.value is undefined in Blackberry 4.7 but
2445				// uses .value. See #6932
2446				var val = elem.attributes.value;
2447				return !val || val.specified ? elem.value : elem.text;
2448			}
2449		},
2450		select: {
2451			get: function( elem ) {
2452				var value, i, max, option,
2453					index = elem.selectedIndex,
2454					values = [],
2455					options = elem.options,
2456					one = elem.type === "select-one";
2457
2458				// Nothing was selected
2459				if ( index < 0 ) {
2460					return null;
2461				}
2462
2463				// Loop through all the selected options
2464				i = one ? index : 0;
2465				max = one ? index + 1 : options.length;
2466				for ( ; i < max; i++ ) {
2467					option = options[ i ];
2468
2469					// Don't return options that are disabled or in a disabled optgroup
2470					if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2471							(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
2472
2473						// Get the specific value for the option
2474						value = jQuery( option ).val();
2475
2476						// We don't need an array for one selects
2477						if ( one ) {
2478							return value;
2479						}
2480
2481						// Multi-Selects return an array
2482						values.push( value );
2483					}
2484				}
2485
2486				// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2487				if ( one && !values.length && options.length ) {
2488					return jQuery( options[ index ] ).val();
2489				}
2490
2491				return values;
2492			},
2493
2494			set: function( elem, value ) {
2495				var values = jQuery.makeArray( value );
2496
2497				jQuery(elem).find("option").each(function() {
2498					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2499				});
2500
2501				if ( !values.length ) {
2502					elem.selectedIndex = -1;
2503				}
2504				return values;
2505			}
2506		}
2507	},
2508
2509	attrFn: {
2510		val: true,
2511		css: true,
2512		html: true,
2513		text: true,
2514		data: true,
2515		width: true,
2516		height: true,
2517		offset: true
2518	},
2519
2520	attr: function( elem, name, value, pass ) {
2521		var ret, hooks, notxml,
2522			nType = elem.nodeType;
2523
2524		// don't get/set attributes on text, comment and attribute nodes
2525		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2526			return;
2527		}
2528
2529		if ( pass && name in jQuery.attrFn ) {
2530			return jQuery( elem )[ name ]( value );
2531		}
2532
2533		// Fallback to prop when attributes are not supported
2534		if ( typeof elem.getAttribute === "undefined" ) {
2535			return jQuery.prop( elem, name, value );
2536		}
2537
2538		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2539
2540		// All attributes are lowercase
2541		// Grab necessary hook if one is defined
2542		if ( notxml ) {
2543			name = name.toLowerCase();
2544			hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
2545		}
2546
2547		if ( value !== undefined ) {
2548
2549			if ( value === null ) {
2550				jQuery.removeAttr( elem, name );
2551				return;
2552
2553			} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2554				return ret;
2555
2556			} else {
2557				elem.setAttribute( name, "" + value );
2558				return value;
2559			}
2560
2561		} else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
2562			return ret;
2563
2564		} else {
2565
2566			ret = elem.getAttribute( name );
2567
2568			// Non-existent attributes return null, we normalize to undefined
2569			return ret === null ?
2570				undefined :
2571				ret;
2572		}
2573	},
2574
2575	removeAttr: function( elem, value ) {
2576		var propName, attrNames, name, l, isBool,
2577			i = 0;
2578
2579		if ( value && elem.nodeType === 1 ) {
2580			attrNames = value.toLowerCase().split( rspace );
2581			l = attrNames.length;
2582
2583			for ( ; i < l; i++ ) {
2584				name = attrNames[ i ];
2585
2586				if ( name ) {
2587					propName = jQuery.propFix[ name ] || name;
2588					isBool = rboolean.test( name );
2589
2590					// See #9699 for explanation of this approach (setting first, then removal)
2591					// Do not do this for boolean attributes (see #10870)
2592					if ( !isBool ) {
2593						jQuery.attr( elem, name, "" );
2594					}
2595					elem.removeAttribute( getSetAttribute ? name : propName );
2596
2597					// Set corresponding property to false for boolean attributes
2598					if ( isBool && propName in elem ) {
2599						elem[ propName ] = false;
2600					}
2601				}
2602			}
2603		}
2604	},
2605
2606	attrHooks: {
2607		type: {
2608			set: function( elem, value ) {
2609				// We can't allow the type property to be changed (since it causes problems in IE)
2610				if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
2611					jQuery.error( "type property can't be changed" );
2612				} else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2613					// Setting the type on a radio button after the value resets the value in IE6-9
2614					// Reset value to it's default in case type is set after value
2615					// This is for element creation
2616					var val = elem.value;
2617					elem.setAttribute( "type", value );
2618					if ( val ) {
2619						elem.value = val;
2620					}
2621					return value;
2622				}
2623			}
2624		},
2625		// Use the value property for back compat
2626		// Use the nodeHook for button elements in IE6/7 (#1954)
2627		value: {
2628			get: function( elem, name ) {
2629				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2630					return nodeHook.get( elem, name );
2631				}
2632				return name in elem ?
2633					elem.value :
2634					null;
2635			},
2636			set: function( elem, value, name ) {
2637				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2638					return nodeHook.set( elem, value, name );
2639				}
2640				// Does not return so that setAttribute is also used
2641				elem.value = value;
2642			}
2643		}
2644	},
2645
2646	propFix: {
2647		tabindex: "tabIndex",
2648		readonly: "readOnly",
2649		"for": "htmlFor",
2650		"class": "className",
2651		maxlength: "maxLength",
2652		cellspacing: "cellSpacing",
2653		cellpadding: "cellPadding",
2654		rowspan: "rowSpan",
2655		colspan: "colSpan",
2656		usemap: "useMap",
2657		frameborder: "frameBorder",
2658		contenteditable: "contentEditable"
2659	},
2660
2661	prop: function( elem, name, value ) {
2662		var ret, hooks, notxml,
2663			nType = elem.nodeType;
2664
2665		// don't get/set properties on text, comment and attribute nodes
2666		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2667			return;
2668		}
2669
2670		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2671
2672		if ( notxml ) {
2673			// Fix name and attach hooks
2674			name = jQuery.propFix[ name ] || name;
2675			hooks = jQuery.propHooks[ name ];
2676		}
2677
2678		if ( value !== undefined ) {
2679			if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2680				return ret;
2681
2682			} else {
2683				return ( elem[ name ] = value );
2684			}
2685
2686		} else {
2687			if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
2688				return ret;
2689
2690			} else {
2691				return elem[ name ];
2692			}
2693		}
2694	},
2695
2696	propHooks: {
2697		tabIndex: {
2698			get: function( elem ) {
2699				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2700				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2701				var attributeNode = elem.getAttributeNode("tabindex");
2702
2703				return attributeNode && attributeNode.specified ?
2704					parseInt( attributeNode.value, 10 ) :
2705					rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
2706						0 :
2707						undefined;
2708			}
2709		}
2710	}
2711});
2712
2713// Add the tabIndex propHook to attrHooks for back-compat (different case is intentional)
2714jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex;
2715
2716// Hook for boolean attributes
2717boolHook = {
2718	get: function( elem, name ) {
2719		// Align boolean attributes with corresponding properties
2720		// Fall back to attribute presence where some booleans are not supported
2721		var attrNode,
2722			property = jQuery.prop( elem, name );
2723		return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
2724			name.toLowerCase() :
2725			undefined;
2726	},
2727	set: function( elem, value, name ) {
2728		var propName;
2729		if ( value === false ) {
2730			// Remove boolean attributes when set to false
2731			jQuery.removeAttr( elem, name );
2732		} else {
2733			// value is true since we know at this point it's type boolean and not false
2734			// Set boolean attributes to the same name and set the DOM property
2735			propName = jQuery.propFix[ name ] || name;
2736			if ( propName in elem ) {
2737				// Only set the IDL specifically if it already exists on the element
2738				elem[ propName ] = true;
2739			}
2740
2741			elem.setAttribute( name, name.toLowerCase() );
2742		}
2743		return name;
2744	}
2745};
2746
2747// IE6/7 do not support getting/setting some attributes with get/setAttribute
2748if ( !getSetAttribute ) {
2749
2750	fixSpecified = {
2751		name: true,
2752		id: true,
2753		coords: true
2754	};
2755
2756	// Use this for any attribute in IE6/7
2757	// This fixes almost every IE6/7 issue
2758	nodeHook = jQuery.valHooks.button = {
2759		get: function( elem, name ) {
2760			var ret;
2761			ret = elem.getAttributeNode( name );
2762			return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ?
2763				ret.nodeValue :
2764				undefined;
2765		},
2766		set: function( elem, value, name ) {
2767			// Set the existing or create a new attribute node
2768			var ret = elem.getAttributeNode( name );
2769			if ( !ret ) {
2770				ret = document.createAttribute( name );
2771				elem.setAttributeNode( ret );
2772			}
2773			return ( ret.nodeValue = value + "" );
2774		}
2775	};
2776
2777	// Apply the nodeHook to tabindex
2778	jQuery.attrHooks.tabindex.set = nodeHook.set;
2779
2780	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
2781	// This is for removals
2782	jQuery.each([ "width", "height" ], function( i, name ) {
2783		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2784			set: function( elem, value ) {
2785				if ( value === "" ) {
2786					elem.setAttribute( name, "auto" );
2787					return value;
2788				}
2789			}
2790		});
2791	});
2792
2793	// Set contenteditable to false on removals(#10429)
2794	// Setting to empty string throws an error as an invalid value
2795	jQuery.attrHooks.contenteditable = {
2796		get: nodeHook.get,
2797		set: function( elem, value, name ) {
2798			if ( value === "" ) {
2799				value = "false";
2800			}
2801			nodeHook.set( elem, value, name );
2802		}
2803	};
2804}
2805
2806
2807// Some attributes require a special call on IE
2808if ( !jQuery.support.hrefNormalized ) {
2809	jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
2810		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2811			get: function( elem ) {
2812				var ret = elem.getAttribute( name, 2 );
2813				return ret === null ? undefined : ret;
2814			}
2815		});
2816	});
2817}
2818
2819if ( !jQuery.support.style ) {
2820	jQuery.attrHooks.style = {
2821		get: function( elem ) {
2822			// Return undefined in the case of empty string
2823			// Normalize to lowercase since IE uppercases css property names
2824			return elem.style.cssText.toLowerCase() || undefined;
2825		},
2826		set: function( elem, value ) {
2827			return ( elem.style.cssText = "" + value );
2828		}
2829	};
2830}
2831
2832// Safari mis-reports the default selected property of an option
2833// Accessing the parent's selectedIndex property fixes it
2834if ( !jQuery.support.optSelected ) {
2835	jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
2836		get: function( elem ) {
2837			var parent = elem.parentNode;
2838
2839			if ( parent ) {
2840				parent.selectedIndex;
2841
2842				// Make sure that it also works with optgroups, see #5701
2843				if ( parent.parentNode ) {
2844					parent.parentNode.selectedIndex;
2845				}
2846			}
2847			return null;
2848		}
2849	});
2850}
2851
2852// IE6/7 call enctype encoding
2853if ( !jQuery.support.enctype ) {
2854	jQuery.propFix.enctype = "encoding";
2855}
2856
2857// Radios and checkboxes getter/setter
2858if ( !jQuery.support.checkOn ) {
2859	jQuery.each([ "radio", "checkbox" ], function() {
2860		jQuery.valHooks[ this ] = {
2861			get: function( elem ) {
2862				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2863				return elem.getAttribute("value") === null ? "on" : elem.value;
2864			}
2865		};
2866	});
2867}
2868jQuery.each([ "radio", "checkbox" ], function() {
2869	jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2870		set: function( elem, value ) {
2871			if ( jQuery.isArray( value ) ) {
2872				return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
2873			}
2874		}
2875	});
2876});
2877
2878
2879
2880
2881var rformElems = /^(?:textarea|input|select)$/i,
2882	rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/,
2883	rhoverHack = /(?:^|\s)hover(\.\S+)?\b/,
2884	rkeyEvent = /^key/,
2885	rmouseEvent = /^(?:mouse|contextmenu)|click/,
2886	rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
2887	rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,
2888	quickParse = function( selector ) {
2889		var quick = rquickIs.exec( selector );
2890		if ( quick ) {
2891			//   0  1    2   3
2892			// [ _, tag, id, class ]
2893			quick[1] = ( quick[1] || "" ).toLowerCase();
2894			quick[3] = quick[3] && new RegExp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" );
2895		}
2896		return quick;
2897	},
2898	quickIs = function( elem, m ) {
2899		var attrs = elem.attributes || {};
2900		return (
2901			(!m[1] || elem.nodeName.toLowerCase() === m[1]) &&
2902			(!m[2] || (attrs.id || {}).value === m[2]) &&
2903			(!m[3] || m[3].test( (attrs[ "class" ] || {}).value ))
2904		);
2905	},
2906	hoverHack = function( events ) {
2907		return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
2908	};
2909
2910/*
2911 * Helper functions for managing events -- not part of the public interface.
2912 * Props to Dean Edwards' addEvent library for many of the ideas.
2913 */
2914jQuery.event = {
2915
2916	add: function( elem, types, handler, data, selector ) {
2917
2918		var elemData, eventHandle, events,
2919			t, tns, type, namespaces, handleObj,
2920			handleObjIn, quick, handlers, special;
2921
2922		// Don't attach events to noData or text/comment nodes (allow plain objects tho)
2923		if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
2924			return;
2925		}
2926
2927		// Caller can pass in an object of custom data in lieu of the handler
2928		if ( handler.handler ) {
2929			handleObjIn = handler;
2930			handler = handleObjIn.handler;
2931			selector = handleObjIn.selector;
2932		}
2933
2934		// Make sure that the handler has a unique ID, used to find/remove it later
2935		if ( !handler.guid ) {
2936			handler.guid = jQuery.guid++;
2937		}
2938
2939		// Init the element's event structure and main handler, if this is the first
2940		events = elemData.events;
2941		if ( !events ) {
2942			elemData.events = events = {};
2943		}
2944		eventHandle = elemData.handle;
2945		if ( !eventHandle ) {
2946			elemData.handle = eventHandle = function( e ) {
2947				// Discard the second event of a jQuery.event.trigger() and
2948				// when an event is called after a page has unloaded
2949				return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
2950					jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
2951					undefined;
2952			};
2953			// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
2954			eventHandle.elem = elem;
2955		}
2956
2957		// Handle multiple events separated by a space
2958		// jQuery(...).bind("mouseover mouseout", fn);
2959		types = jQuery.trim( hoverHack(types) ).split( " " );
2960		for ( t = 0; t < types.length; t++ ) {
2961
2962			tns = rtypenamespace.exec( types[t] ) || [];
2963			type = tns[1];
2964			namespaces = ( tns[2] || "" ).split( "." ).sort();
2965
2966			// If event changes its type, use the special event handlers for the changed type
2967			special = jQuery.event.special[ type ] || {};
2968
2969			// If selector defined, determine special event api type, otherwise given type
2970			type = ( selector ? special.delegateType : special.bindType ) || type;
2971
2972			// Update special based on newly reset type
2973			special = jQuery.event.special[ type ] || {};
2974
2975			// handleObj is passed to all event handlers
2976			handleObj = jQuery.extend({
2977				type: type,
2978				origType: tns[1],
2979				data: data,
2980				handler: handler,
2981				guid: handler.guid,
2982				selector: selector,
2983				quick: selector && quickParse( selector ),
2984				namespace: namespaces.join(".")
2985			}, handleObjIn );
2986
2987			// Init the event handler queue if we're the first
2988			handlers = events[ type ];
2989			if ( !handlers ) {
2990				handlers = events[ type ] = [];
2991				handlers.delegateCount = 0;
2992
2993				// Only use addEventListener/attachEvent if the special events handler returns false
2994				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2995					// Bind the global event handler to the element
2996					if ( elem.addEventListener ) {
2997						elem.addEventListener( type, eventHandle, false );
2998
2999					} else if ( elem.attachEvent ) {
3000						elem.attachEvent( "on" + type, eventHandle );
3001					}
3002				}
3003			}
3004
3005			if ( special.add ) {
3006				special.add.call( elem, handleObj );
3007
3008				if ( !handleObj.handler.guid ) {
3009					handleObj.handler.guid = handler.guid;
3010				}
3011			}
3012
3013			// Add to the element's handler list, delegates in front
3014			if ( selector ) {
3015				handlers.splice( handlers.delegateCount++, 0, handleObj );
3016			} else {
3017				handlers.push( handleObj );
3018			}
3019
3020			// Keep track of which events have ever been used, for event optimization
3021			jQuery.event.global[ type ] = true;
3022		}
3023
3024		// Nullify elem to prevent memory leaks in IE
3025		elem = null;
3026	},
3027
3028	global: {},
3029
3030	// Detach an event or set of events from an element
3031	remove: function( elem, types, handler, selector, mappedTypes ) {
3032
3033		var elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
3034			t, tns, type, origType, namespaces, origCount,
3035			j, events, special, handle, eventType, handleObj;
3036
3037		if ( !elemData || !(events = elemData.events) ) {
3038			return;
3039		}
3040
3041		// Once for each type.namespace in types; type may be omitted
3042		types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
3043		for ( t = 0; t < types.length; t++ ) {
3044			tns = rtypenamespace.exec( types[t] ) || [];
3045			type = origType = tns[1];
3046			namespaces = tns[2];
3047
3048			// Unbind all events (on this namespace, if provided) for the element
3049			if ( !type ) {
3050				for ( type in events ) {
3051					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
3052				}
3053				continue;
3054			}
3055
3056			special = jQuery.event.special[ type ] || {};
3057			type = ( selector? special.delegateType : special.bindType ) || type;
3058			eventType = events[ type ] || [];
3059			origCount = eventType.length;
3060			namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
3061
3062			// Remove matching events
3063			for ( j = 0; j < eventType.length; j++ ) {
3064				handleObj = eventType[ j ];
3065
3066				if ( ( mappedTypes || origType === handleObj.origType ) &&
3067					 ( !handler || handler.guid === handleObj.guid ) &&
3068					 ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
3069					 ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
3070					eventType.splice( j--, 1 );
3071
3072					if ( handleObj.selector ) {
3073						eventType.delegateCount--;
3074					}
3075					if ( special.remove ) {
3076						special.remove.call( elem, handleObj );
3077					}
3078				}
3079			}
3080
3081			// Remove generic event handler if we removed something and no more handlers exist
3082			// (avoids potential for endless recursion during removal of special event handlers)
3083			if ( eventType.length === 0 && origCount !== eventType.length ) {
3084				if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
3085					jQuery.removeEvent( elem, type, elemData.handle );
3086				}
3087
3088				delete events[ type ];
3089			}
3090		}
3091
3092		// Remove the expando if it's no longer used
3093		if ( jQuery.isEmptyObject( events ) ) {
3094			handle = elemData.handle;
3095			if ( handle ) {
3096				handle.elem = null;
3097			}
3098
3099			// removeData also checks for emptiness and clears the expando if empty
3100			// so use it instead of delete
3101			jQuery.removeData( elem, [ "events", "handle" ], true );
3102		}
3103	},
3104
3105	// Events that are safe to short-circuit if no handlers are attached.
3106	// Native DOM events should not be added, they may have inline handlers.
3107	customEvent: {
3108		"getData": true,
3109		"setData": true,
3110		"changeData": true
3111	},
3112
3113	trigger: function( event, data, elem, onlyHandlers ) {
3114		// Don't do events on text and comment nodes
3115		if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
3116			return;
3117		}
3118
3119		// Event object or event type
3120		var type = event.type || event,
3121			namespaces = [],
3122			cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType;
3123
3124		// focus/blur morphs to focusin/out; ensure we're not firing them right now
3125		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
3126			return;
3127		}
3128
3129		if ( type.indexOf( "!" ) >= 0 ) {
3130			// Exclusive events trigger only for the exact event (no namespaces)
3131			type = type.slice(0, -1);
3132			exclusive = true;
3133		}
3134
3135		if ( type.indexOf( "." ) >= 0 ) {
3136			// Namespaced trigger; create a regexp to match event type in handle()
3137			namespaces = type.split(".");
3138			type = namespaces.shift();
3139			namespaces.sort();
3140		}
3141
3142		if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
3143			// No jQuery handlers for this event type, and it can't have inline handlers
3144			return;
3145		}
3146
3147		// Caller can pass in an Event, Object, or just an event type string
3148		event = typeof event === "object" ?
3149			// jQuery.Event object
3150			event[ jQuery.expando ] ? event :
3151			// Object literal
3152			new jQuery.Event( type, event ) :
3153			// Just the event type (string)
3154			new jQuery.Event( type );
3155
3156		event.type = type;
3157		event.isTrigger = true;
3158		event.exclusive = exclusive;
3159		event.namespace = namespaces.join( "." );
3160		event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
3161		ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
3162
3163		// Handle a global trigger
3164		if ( !elem ) {
3165
3166			// TODO: Stop taunting the data cache; remove global events and always attach to document
3167			cache = jQuery.cache;
3168			for ( i in cache ) {
3169				if ( cache[ i ].events && cache[ i ].events[ type ] ) {
3170					jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
3171				}
3172			}
3173			return;
3174		}
3175
3176		// Clean up the event in case it is being reused
3177		event.result = undefined;
3178		if ( !event.target ) {
3179			event.target = elem;
3180		}
3181
3182		// Clone any incoming data and prepend the event, creating the handler arg list
3183		data = data != null ? jQuery.makeArray( data ) : [];
3184		data.unshift( event );
3185
3186		// Allow special events to draw outside the lines
3187		special = jQuery.event.special[ type ] || {};
3188		if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
3189			return;
3190		}
3191
3192		// Determine event propagation path in advance, per W3C events spec (#9951)
3193		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
3194		eventPath = [[ elem, special.bindType || type ]];
3195		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
3196
3197			bubbleType = special.delegateType || type;
3198			cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
3199			old = null;
3200			for ( ; cur; cur = cur.parentNode ) {
3201				eventPath.push([ cur, bubbleType ]);
3202				old = cur;
3203			}
3204
3205			// Only add window if we got to document (e.g., not plain obj or detached DOM)
3206			if ( old && old === elem.ownerDocument ) {
3207				eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
3208			}
3209		}
3210
3211		// Fire handlers on the event path
3212		for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
3213
3214			cur = eventPath[i][0];
3215			event.type = eventPath[i][1];
3216
3217			handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
3218			if ( handle ) {
3219				handle.apply( cur, data );
3220			}
3221			// Note that this is a bare JS function and not a jQuery handler
3222			handle = ontype && cur[ ontype ];
3223			if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) {
3224				event.preventDefault();
3225			}
3226		}
3227		event.type = type;
3228
3229		// If nobody prevented the default action, do it now
3230		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
3231
3232			if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
3233				!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
3234
3235				// Call a native DOM method on the target with the same name name as the event.
3236				// Can't use an .isFunction() check here because IE6/7 fails that test.
3237				// Don't do default actions on window, that's where global variables be (#6170)
3238				// IE<9 dies on focus/blur to hidden element (#1486)
3239				if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
3240
3241					// Don't re-trigger an onFOO event when we call its FOO() method
3242					old = elem[ ontype ];
3243
3244					if ( old ) {
3245						elem[ ontype ] = null;
3246					}
3247
3248					// Prevent re-triggering of the same event, since we already bubbled it above
3249					jQuery.event.triggered = type;
3250					elem[ type ]();
3251					jQuery.event.triggered = undefined;
3252
3253					if ( old ) {
3254						elem[ ontype ] = old;
3255					}
3256				}
3257			}
3258		}
3259
3260		return event.result;
3261	},
3262
3263	dispatch: function( event ) {
3264
3265		// Make a writable jQuery.Event from the native event object
3266		event = jQuery.event.fix( event || window.event );
3267
3268		var handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
3269			delegateCount = handlers.delegateCount,
3270			args = [].slice.call( arguments, 0 ),
3271			run_all = !event.exclusive && !event.namespace,
3272			special = jQuery.event.special[ event.type ] || {},
3273			handlerQueue = [],
3274			i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related;
3275
3276		// Use the fix-ed jQuery.Event rather than the (read-only) native event
3277		args[0] = event;
3278		event.delegateTarget = this;
3279
3280		// Call the preDispatch hook for the mapped type, and let it bail if desired
3281		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
3282			return;
3283		}
3284
3285		// Determine handlers that should run if there are delegated events
3286		// Avoid non-left-click bubbling in Firefox (#3861)
3287		if ( delegateCount && !(event.button && event.type === "click") ) {
3288
3289			// Pregenerate a single jQuery object for reuse with .is()
3290			jqcur = jQuery(this);
3291			jqcur.context = this.ownerDocument || this;
3292
3293			for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
3294
3295				// Don't process events on disabled elements (#6911, #8165)
3296				if ( cur.disabled !== true ) {
3297					selMatch = {};
3298					matches = [];
3299					jqcur[0] = cur;
3300					for ( i = 0; i < delegateCount; i++ ) {
3301						handleObj = handlers[ i ];
3302						sel = handleObj.selector;
3303
3304						if ( selMatch[ sel ] === undefined ) {
3305							selMatch[ sel ] = (
3306								handleObj.quick ? quickIs( cur, handleObj.quick ) : jqcur.is( sel )
3307							);
3308						}
3309						if ( selMatch[ sel ] ) {
3310							matches.push( handleObj );
3311						}
3312					}
3313					if ( matches.length ) {
3314						handlerQueue.push({ elem: cur, matches: matches });
3315					}
3316				}
3317			}
3318		}
3319
3320		// Add the remaining (directly-bound) handlers
3321		if ( handlers.length > delegateCount ) {
3322			handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
3323		}
3324
3325		// Run delegates first; they may want to stop propagation beneath us
3326		for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
3327			matched = handlerQueue[ i ];
3328			event.currentTarget = matched.elem;
3329
3330			for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
3331				handleObj = matched.matches[ j ];
3332
3333				// Triggered event must either 1) be non-exclusive and have no namespace, or
3334				// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
3335				if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
3336
3337					event.data = handleObj.data;
3338					event.handleObj = handleObj;
3339
3340					ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
3341							.apply( matched.elem, args );
3342
3343					if ( ret !== undefined ) {
3344						event.result = ret;
3345						if ( ret === false ) {
3346							event.preventDefault();
3347							event.stopPropagation();
3348						}
3349					}
3350				}
3351			}
3352		}
3353
3354		// Call the postDispatch hook for the mapped type
3355		if ( special.postDispatch ) {
3356			special.postDispatch.call( this, event );
3357		}
3358
3359		return event.result;
3360	},
3361
3362	// Includes some event props shared by KeyEvent and MouseEvent
3363	// *** attrChange attrName relatedNode srcElement  are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
3364	props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
3365
3366	fixHooks: {},
3367
3368	keyHooks: {
3369		props: "char charCode key keyCode".split(" "),
3370		filter: function( event, original ) {
3371
3372			// Add which for key events
3373			if ( event.which == null ) {
3374				event.which = original.charCode != null ? original.charCode : original.keyCode;
3375			}
3376
3377			return event;
3378		}
3379	},
3380
3381	mouseHooks: {
3382		props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
3383		filter: function( event, original ) {
3384			var eventDoc, doc, body,
3385				button = original.button,
3386				fromElement = original.fromElement;
3387
3388			// Calculate pageX/Y if missing and clientX/Y available
3389			if ( event.pageX == null && original.clientX != null ) {
3390				eventDoc = event.target.ownerDocument || document;
3391				doc = eventDoc.documentElement;
3392				body = eventDoc.body;
3393
3394				event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
3395				event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
3396			}
3397
3398			// Add relatedTarget, if necessary
3399			if ( !event.relatedTarget && fromElement ) {
3400				event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
3401			}
3402
3403			// Add which for click: 1 === left; 2 === middle; 3 === right
3404			// Note: button is not normalized, so don't use it
3405			if ( !event.which && button !== undefined ) {
3406				event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
3407			}
3408
3409			return event;
3410		}
3411	},
3412
3413	fix: function( event ) {
3414		if ( event[ jQuery.expando ] ) {
3415			return event;
3416		}
3417
3418		// Create a writable copy of the event object and normalize some properties
3419		var i, prop,
3420			originalEvent = event,
3421			fixHook = jQuery.event.fixHooks[ event.type ] || {},
3422			copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
3423
3424		event = jQuery.Event( originalEvent );
3425
3426		for ( i = copy.length; i; ) {
3427			prop = copy[ --i ];
3428			event[ prop ] = originalEvent[ prop ];
3429		}
3430
3431		// Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
3432		if ( !event.target ) {
3433			event.target = originalEvent.srcElement || document;
3434		}
3435
3436		// Target should not be a text node (#504, Safari)
3437		if ( event.target.nodeType === 3 ) {
3438			event.target = event.target.parentNode;
3439		}
3440
3441		// For mouse/key events; add metaKey if it's not there (#3368, IE6/7/8)
3442		if ( event.metaKey === undefined ) {
3443			event.metaKey = event.ctrlKey;
3444		}
3445
3446		return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
3447	},
3448
3449	special: {
3450		ready: {
3451			// Make sure the ready event is setup
3452			setup: jQuery.bindReady
3453		},
3454
3455		load: {
3456			// Prevent triggered image.load events from bubbling to window.load
3457			noBubble: true
3458		},
3459
3460		focus: {
3461			delegateType: "focusin"
3462		},
3463		blur: {
3464			delegateType: "focusout"
3465		},
3466
3467		beforeunload: {
3468			setup: function( data, namespaces, eventHandle ) {
3469				// We only want to do this special case on windows
3470				if ( jQuery.isWindow( this ) ) {
3471					this.onbeforeunload = eventHandle;
3472				}
3473			},
3474
3475			teardown: function( namespaces, eventHandle ) {
3476				if ( this.onbeforeunload === eventHandle ) {
3477					this.onbeforeunload = null;
3478				}
3479			}
3480		}
3481	},
3482
3483	simulate: function( type, elem, event, bubble ) {
3484		// Piggyback on a donor event to simulate a different one.
3485		// Fake originalEvent to avoid donor's stopPropagation, but if the
3486		// simulated event prevents default then we do the same on the donor.
3487		var e = jQuery.extend(
3488			new jQuery.Event(),
3489			event,
3490			{ type: type,
3491				isSimulated: true,
3492				originalEvent: {}
3493			}
3494		);
3495		if ( bubble ) {
3496			jQuery.event.trigger( e, null, elem );
3497		} else {
3498			jQuery.event.dispatch.call( elem, e );
3499		}
3500		if ( e.isDefaultPrevented() ) {
3501			event.preventDefault();
3502		}
3503	}
3504};
3505
3506// Some plugins are using, but it's undocumented/deprecated and will be removed.
3507// The 1.7 special event interface should provide all the hooks needed now.
3508jQuery.event.handle = jQuery.event.dispatch;
3509
3510jQuery.removeEvent = document.removeEventListener ?
3511	function( elem, type, handle ) {
3512		if ( elem.removeEventListener ) {
3513			elem.removeEventListener( type, handle, false );
3514		}
3515	} :
3516	function( elem, type, handle ) {
3517		if ( elem.detachEvent ) {
3518			elem.detachEvent( "on" + type, handle );
3519		}
3520	};
3521
3522jQuery.Event = function( src, props ) {
3523	// Allow instantiation without the 'new' keyword
3524	if ( !(this instanceof jQuery.Event) ) {
3525		return new jQuery.Event( src, props );
3526	}
3527
3528	// Event object
3529	if ( src && src.type ) {
3530		this.originalEvent = src;
3531		this.type = src.type;
3532
3533		// Events bubbling up the document may have been marked as prevented
3534		// by a handler lower down the tree; reflect the correct value.
3535		this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
3536			src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
3537
3538	// Event type
3539	} else {
3540		this.type = src;
3541	}
3542
3543	// Put explicitly provided properties onto the event object
3544	if ( props ) {
3545		jQuery.extend( this, props );
3546	}
3547
3548	// Create a timestamp if incoming event doesn't have one
3549	this.timeStamp = src && src.timeStamp || jQuery.now();
3550
3551	// Mark it as fixed
3552	this[ jQuery.expando ] = true;
3553};
3554
3555function returnFalse() {
3556	return false;
3557}
3558function returnTrue() {
3559	return true;
3560}
3561
3562// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
3563// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
3564jQuery.Event.prototype = {
3565	preventDefault: function() {
3566		this.isDefaultPrevented = returnTrue;
3567
3568		var e = this.originalEvent;
3569		if ( !e ) {
3570			return;
3571		}
3572
3573		// if preventDefault exists run it on the original event
3574		if ( e.preventDefault ) {
3575			e.preventDefault();
3576
3577		// otherwise set the returnValue property of the original event to false (IE)
3578		} else {
3579			e.returnValue = false;
3580		}
3581	},
3582	stopPropagation: function() {
3583		this.isPropagationStopped = returnTrue;
3584
3585		var e = this.originalEvent;
3586		if ( !e ) {
3587			return;
3588		}
3589		// if stopPropagation exists run it on the original event
3590		if ( e.stopPropagation ) {
3591			e.stopPropagation();
3592		}
3593		// otherwise set the cancelBubble property of the original event to true (IE)
3594		e.cancelBubble = true;
3595	},
3596	stopImmediatePropagation: function() {
3597		this.isImmediatePropagationStopped = returnTrue;
3598		this.stopPropagation();
3599	},
3600	isDefaultPrevented: returnFalse,
3601	isPropagationStopped: returnFalse,
3602	isImmediatePropagationStopped: returnFalse
3603};
3604
3605// Create mouseenter/leave events using mouseover/out and event-time checks
3606jQuery.each({
3607	mouseenter: "mouseover",
3608	mouseleave: "mouseout"
3609}, function( orig, fix ) {
3610	jQuery.event.special[ orig ] = {
3611		delegateType: fix,
3612		bindType: fix,
3613
3614		handle: function( event ) {
3615			var target = this,
3616				related = event.relatedTarget,
3617				handleObj = event.handleObj,
3618				selector = handleObj.selector,
3619				ret;
3620
3621			// For mousenter/leave call the handler if related is outside the target.
3622			// NB: No relatedTarget if the mouse left/entered the browser window
3623			if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
3624				event.type = handleObj.origType;
3625				ret = handleObj.handler.apply( this, arguments );
3626				event.type = fix;
3627			}
3628			return ret;
3629		}
3630	};
3631});
3632
3633// IE submit delegation
3634if ( !jQuery.support.submitBubbles ) {
3635
3636	jQuery.event.special.submit = {
3637		setup: function() {
3638			// Only need this for delegated form submit events
3639			if ( jQuery.nodeName( this, "form" ) ) {
3640				return false;
3641			}
3642
3643			// Lazy-add a submit handler when a descendant form may potentially be submitted
3644			jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
3645				// Node name check avoids a VML-related crash in IE (#9807)
3646				var elem = e.target,
3647					form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
3648				if ( form && !form._submit_attached ) {
3649					jQuery.event.add( form, "submit._submit", function( event ) {
3650						event._submit_bubble = true;
3651					});
3652					form._submit_attached = true;
3653				}
3654			});
3655			// return undefined since we don't need an event listener
3656		},
3657		
3658		postDispatch: function( event ) {
3659			// If form was submitted by the user, bubble the event up the tree
3660			if ( event._submit_bubble ) {
3661				delete event._submit_bubble;
3662				if ( this.parentNode && !event.isTrigger ) {
3663					jQuery.event.simulate( "submit", this.parentNode, event, true );
3664				}
3665			}
3666		},
3667
3668		teardown: function() {
3669			// Only need this for delegated form submit events
3670			if ( jQuery.nodeName( this, "form" ) ) {
3671				return false;
3672			}
3673
3674			// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
3675			jQuery.event.remove( this, "._submit" );
3676		}
3677	};
3678}
3679
3680// IE change delegation and checkbox/radio fix
3681if ( !jQuery.support.changeBubbles ) {
3682
3683	jQuery.event.special.change = {
3684
3685		setup: function() {
3686
3687			if ( rformElems.test( this.nodeName ) ) {
3688				// IE doesn't fire change on a check/radio until blur; trigger it on click
3689				// after a propertychange. Eat the blur-change in special.change.handle.
3690				// This still fires onchange a second time for check/radio after blur.
3691				if ( this.type === "checkbox" || this.type === "radio" ) {
3692					jQuery.event.add( this, "propertychange._change", function( event ) {
3693						if ( event.originalEvent.propertyName === "checked" ) {
3694							this._just_changed = true;
3695						}
3696					});
3697					jQuery.event.add( this, "click._change", function( event ) {
3698						if ( this._just_changed && !event.isTrigger ) {
3699							this._just_changed = false;
3700							jQuery.event.simulate( "change", this, event, true );
3701						}
3702					});
3703				}
3704				return false;
3705			}
3706			// Delegated event; lazy-add a change handler on descendant inputs
3707			jQuery.event.add( this, "beforeactivate._change", function( e ) {
3708				var elem = e.target;
3709
3710				if ( rformElems.test( elem.nodeName ) && !elem._change_attached ) {
3711					jQuery.event.add( elem, "change._change", function( event ) {
3712						if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
3713							jQuery.event.simulate( "change", this.parentNode, event, true );
3714						}
3715					});
3716					elem._change_attached = true;
3717				}
3718			});
3719		},
3720
3721		handle: function( event ) {
3722			var elem = event.target;
3723
3724			// Swallow native change events from checkbox/radio, we already triggered them above
3725			if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
3726				return event.handleObj.handler.apply( this, arguments );
3727			}
3728		},
3729
3730		teardown: function() {
3731			jQuery.event.remove( this, "._change" );
3732
3733			return rformElems.test( this.nodeName );
3734		}
3735	};
3736}
3737
3738// Create "bubbling" focus and blur events
3739if ( !jQuery.support.focusinBubbles ) {
3740	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
3741
3742		// Attach a single capturing handler while someone wants focusin/focusout
3743		var attaches = 0,
3744			handler = function( event ) {
3745				jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
3746			};
3747
3748		jQuery.event.special[ fix ] = {
3749			setup: function() {
3750				if ( attaches++ === 0 ) {
3751					document.addEventListener( orig, handler, true );
3752				}
3753			},
3754			teardown: function() {
3755				if ( --attaches === 0 ) {
3756					document.removeEventListener( orig, handler, true );
3757				}
3758			}
3759		};
3760	});
3761}
3762
3763jQuery.fn.extend({
3764
3765	on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
3766		var origFn, type;
3767
3768		// Types can be a map of types/handlers
3769		if ( typeof types === "object" ) {
3770			// ( types-Object, selector, data )
3771			if ( typeof selector !== "string" ) { // && selector != null
3772				// ( types-Object, data )
3773				data = data || selector;
3774				selector = undefined;
3775			}
3776			for ( type in types ) {
3777				this.on( type, selector, data, types[ type ], one );
3778			}
3779			return this;
3780		}
3781
3782		if ( data == null && fn == null ) {
3783			// ( types, fn )
3784			fn = selector;
3785			data = selector = undefined;
3786		} else if ( fn == null ) {
3787			if ( typeof selector === "string" ) {
3788				// ( types, selector, fn )
3789				fn = data;
3790				data = undefined;
3791			} else {
3792				// ( types, data, fn )
3793				fn = data;
3794				data = selector;
3795				selector = undefined;
3796			}
3797		}
3798		if ( fn === false ) {
3799			fn = returnFalse;
3800		} else if ( !fn ) {
3801			return this;
3802		}
3803
3804		if ( one === 1 ) {
3805			origFn = fn;
3806			fn = function( event ) {
3807				// Can use an empty set, since event contains the info
3808				jQuery().off( event );
3809				return origFn.apply( this, arguments );
3810			};
3811			// Use same guid so caller can remove using origFn
3812			fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
3813		}
3814		return this.each( function() {
3815			jQuery.event.add( this, types, fn, data, selector );
3816		});
3817	},
3818	one: function( types, selector, data, fn ) {
3819		return this.on( types, selector, data, fn, 1 );
3820	},
3821	off: function( types, selector, fn ) {
3822		if ( types && types.preventDefault && types.handleObj ) {
3823			// ( event )  dispatched jQuery.Event
3824			var handleObj = types.handleObj;
3825			jQuery( types.delegateTarget ).off(
3826				handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
3827				handleObj.selector,
3828				handleObj.handler
3829			);
3830			return this;
3831		}
3832		if ( typeof types === "object" ) {
3833			// ( types-object [, selector] )
3834			for ( var type in types ) {
3835				this.off( type, selector, types[ type ] );
3836			}
3837			return this;
3838		}
3839		if ( selector === false || typeof selector === "function" ) {
3840			// ( types [, fn] )
3841			fn = selector;
3842			selector = undefined;
3843		}
3844		if ( fn === false ) {
3845			fn = returnFalse;
3846		}
3847		return this.each(function() {
3848			jQuery.event.remove( this, types, fn, selector );
3849		});
3850	},
3851
3852	bind: function( types, data, fn ) {
3853		return this.on( types, null, data, fn );
3854	},
3855	unbind: function( types, fn ) {
3856		return this.off( types, null, fn );
3857	},
3858
3859	live: function( types, data, fn ) {
3860		jQuery( this.context ).on( types, this.selector, data, fn );
3861		return this;
3862	},
3863	die: function( types, fn ) {
3864		jQuery( this.context ).off( types, this.selector || "**", fn );
3865		return this;
3866	},
3867
3868	delegate: function( selector, types, data, fn ) {
3869		return this.on( types, selector, data, fn );
3870	},
3871	undelegate: function( selector, types, fn ) {
3872		// ( namespace ) or ( selector, types [, fn] )
3873		return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector, fn );
3874	},
3875
3876	trigger: function( type, data ) {
3877		return this.each(function() {
3878			jQuery.event.trigger( type, data, this );
3879		});
3880	},
3881	triggerHandler: function( type, data ) {
3882		if ( this[0] ) {
3883			return jQuery.event.trigger( type, data, this[0], true );
3884		}
3885	},
3886
3887	toggle: function( fn ) {
3888		// Save reference to arguments for access in closure
3889		var args = arguments,
3890			guid = fn.guid || jQuery.guid++,
3891			i = 0,
3892			toggler = function( event ) {
3893				// Figure out which function to execute
3894				var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
3895				jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
3896
3897				// Make sure that clicks stop
3898				event.preventDefault();
3899
3900				// and execute the function
3901				return args[ lastToggle ].apply( this, arguments ) || false;
3902			};
3903
3904		// link all the functions, so any of them can unbind this click handler
3905		toggler.guid = guid;
3906		while ( i < args.length ) {
3907			args[ i++ ].guid = guid;
3908		}
3909
3910		return this.click( toggler );
3911	},
3912
3913	hover: function( fnOver, fnOut ) {
3914		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
3915	}
3916});
3917
3918jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
3919	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
3920	"change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
3921
3922	// Handle event binding
3923	jQuery.fn[ name ] = function( data, fn ) {
3924		if ( fn == null ) {
3925			fn = data;
3926			data = null;
3927		}
3928
3929		return arguments.length > 0 ?
3930			this.on( name, null, data, fn ) :
3931			this.trigger( name );
3932	};
3933
3934	if ( jQuery.attrFn ) {
3935		jQuery.attrFn[ name ] = true;
3936	}
3937