http://hljms.gov.cn/mss/xhtml/script/jquery_1.7.2.js

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

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

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

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