https://www.taxi-geyer.de/js/jquery.js

1/*!
2 * jQuery JavaScript Library v1.8.1
3 * http://jquery.com/
4 *
5 * Includes Sizzle.js
6 * http://sizzlejs.com/
7 *
8 * Copyright 2012 jQuery Foundation and other contributors
9 * Released under the MIT license
10 * http://jquery.org/license
11 *
12 * Date: Thu Aug 30 2012 17:17:22 GMT-0400 (Eastern Daylight Time)
13 */
14(function( window, undefined ) {
15var
16	// A central reference to the root jQuery(document)
17	rootjQuery,
18
19	// The deferred used on DOM ready
20	readyList,
21
22	// Use the correct document accordingly with window argument (sandbox)
23	document = window.document,
24	location = window.location,
25	navigator = window.navigator,
26
27	// Map over jQuery in case of overwrite
28	_jQuery = window.jQuery,
29
30	// Map over the $ in case of overwrite
31	_$ = window.$,
32
33	// Save a reference to some core methods
34	core_push = Array.prototype.push,
35	core_slice = Array.prototype.slice,
36	core_indexOf = Array.prototype.indexOf,
37	core_toString = Object.prototype.toString,
38	core_hasOwn = Object.prototype.hasOwnProperty,
39	core_trim = String.prototype.trim,
40
41	// Define a local copy of jQuery
42	jQuery = function( selector, context ) {
43		// The jQuery object is actually just the init constructor 'enhanced'
44		return new jQuery.fn.init( selector, context, rootjQuery );
45	},
46
47	// Used for matching numbers
48	core_pnum = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source,
49
50	// Used for detecting and trimming whitespace
51	core_rnotwhite = /\S/,
52	core_rspace = /\s+/,
53
54	// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
55	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
56
57	// A simple way to check for HTML strings
58	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
59	rquickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
60
61	// Match a standalone tag
62	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
63
64	// JSON RegExp
65	rvalidchars = /^[\],:{}\s]*$/,
66	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
67	rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
68	rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g,
69
70	// Matches dashed string for camelizing
71	rmsPrefix = /^-ms-/,
72	rdashAlpha = /-([\da-z])/gi,
73
74	// Used by jQuery.camelCase as callback to replace()
75	fcamelCase = function( all, letter ) {
76		return ( letter + "" ).toUpperCase();
77	},
78
79	// The ready event handler and self cleanup method
80	DOMContentLoaded = function() {
81		if ( document.addEventListener ) {
82			document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
83			jQuery.ready();
84		} else if ( document.readyState === "complete" ) {
85			// we're here because readyState === "complete" in oldIE
86			// which is good enough for us to call the dom ready!
87			document.detachEvent( "onreadystatechange", DOMContentLoaded );
88			jQuery.ready();
89		}
90	},
91
92	// [[Class]] -> type pairs
93	class2type = {};
94
95jQuery.fn = jQuery.prototype = {
96	constructor: jQuery,
97	init: function( selector, context, rootjQuery ) {
98		var match, elem, ret, doc;
99
100		// Handle $(""), $(null), $(undefined), $(false)
101		if ( !selector ) {
102			return this;
103		}
104
105		// Handle $(DOMElement)
106		if ( selector.nodeType ) {
107			this.context = this[0] = selector;
108			this.length = 1;
109			return this;
110		}
111
112		// Handle HTML strings
113		if ( typeof selector === "string" ) {
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 = rquickExpr.exec( selector );
120			}
121
122			// Match html or make sure no context is 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.nodeType ? context.ownerDocument || context : document );
129
130					// scripts is true for back-compat
131					selector = jQuery.parseHTML( match[1], doc, true );
132					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
133						this.attr.call( selector, context, true );
134					}
135
136					return jQuery.merge( this, selector );
137
138				// HANDLE: $(#id)
139				} else {
140					elem = document.getElementById( match[2] );
141
142					// Check parentNode to catch when Blackberry 4.6 returns
143					// nodes that are no longer in the document #6963
144					if ( elem && elem.parentNode ) {
145						// Handle the case where IE and Opera return items
146						// by name instead of ID
147						if ( elem.id !== match[2] ) {
148							return rootjQuery.find( selector );
149						}
150
151						// Otherwise, we inject the element directly into the jQuery object
152						this.length = 1;
153						this[0] = elem;
154					}
155
156					this.context = document;
157					this.selector = selector;
158					return this;
159				}
160
161			// HANDLE: $(expr, $(...))
162			} else if ( !context || context.jquery ) {
163				return ( context || rootjQuery ).find( selector );
164
165			// HANDLE: $(expr, context)
166			// (which is just equivalent to: $(context).find(expr)
167			} else {
168				return this.constructor( context ).find( selector );
169			}
170
171		// HANDLE: $(function)
172		// Shortcut for document ready
173		} else if ( jQuery.isFunction( selector ) ) {
174			return rootjQuery.ready( selector );
175		}
176
177		if ( selector.selector !== undefined ) {
178			this.selector = selector.selector;
179			this.context = selector.context;
180		}
181
182		return jQuery.makeArray( selector, this );
183	},
184
185	// Start with an empty selector
186	selector: "",
187
188	// The current version of jQuery being used
189	jquery: "1.8.1

189",
190
191	// The default length of a jQuery object is 0
192	length: 0,
193
194	// The number of elements contained in the matched element set
195	size: function() {
196		return this.length;
197	},
198
199	toArray: function() {
200		return core_slice.call( this );
201	},
202
203	// Get the Nth element in the matched element set OR
204	// Get the whole matched element set as a clean array
205	get: function( num ) {
206		return num == null ?
207
208			// Return a 'clean' array
209			this.toArray() :
210
211			// Return just the object
212			( num < 0 ? this[ this.length + num ] : this[ num ] );
213	},
214
215	// Take an array of elements and push it onto the stack
216	// (returning the new matched element set)
217	pushStack: function( elems, name, selector ) {
218
219		// Build a new jQuery matched element set
220		var ret = jQuery.merge( this.constructor(), elems );
221
222		// Add the old object onto the stack (as a reference)
223		ret.prevObject = this;
224
225		ret.context = this.context;
226
227		if ( name === "find" ) {
228			ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
229		} else if ( name ) {
230			ret.selector = this.selector + "." + name + "(" + selector + ")";
231		}
232
233		// Return the newly-formed element set
234		return ret;
235	},
236
237	// Execute a callback for every element in the matched set.
238	// (You can seed the arguments with an array of args, but this is
239	// only used internally.)
240	each: function( callback, args ) {
241		return jQuery.each( this, callback, args );
242	},
243
244	ready: function( fn ) {
245		// Add the callback
246		jQuery.ready.promise().done( fn );
247
248		return this;
249	},
250
251	eq: function( i ) {
252		i = +i;
253		return i === -1 ?
254			this.slice( i ) :
255			this.slice( i, i + 1 );
256	},
257
258	first: function() {
259		return this.eq( 0 );
260	},
261
262	last: function() {
263		return this.eq( -1 );
264	},
265
266	slice: function() {
267		return this.pushStack( core_slice.apply( this, arguments ),
268			"slice", core_slice.call(arguments).join(",") );
269	},
270
271	map: function( callback ) {
272		return this.pushStack( jQuery.map(this, function( elem, i ) {
273			return callback.call( elem, i, elem );
274		}));
275	},
276
277	end: function() {
278		return this.prevObject || this.constructor(null);
279	},
280
281	// For internal use only.
282	// Behaves like an Array's method, not like a jQuery method.
283	push: core_push,
284	sort: [].sort,
285	splice: [].splice
286};
287
288// Give the init function the jQuery prototype for later instantiation
289jQuery.fn.init.prototype = jQuery.fn;
290
291jQuery.extend = jQuery.fn.extend = function() {
292	var options, name, src, copy, copyIsArray, clone,
293		target = arguments[0] || {},
294		i = 1,
295		length = arguments.length,
296		deep = false;
297
298	// Handle a deep copy situation
299	if ( typeof target === "boolean" ) {
300		deep = target;
301		target = arguments[1] || {};
302		// skip the boolean and the target
303		i = 2;
304	}
305
306	// Handle case when target is a string or something (possible in deep copy)
307	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
308		target = {};
309	}
310
311	// extend jQuery itself if only one argument is passed
312	if ( length === i ) {
313		target = this;
314		--i;
315	}
316
317	for ( ; i < length; i++ ) {
318		// Only deal with non-null/undefined values
319		if ( (options = arguments[ i ]) != null ) {
320			// Extend the base object
321			for ( name in options ) {
322				src = target[ name ];
323				copy = options[ name ];
324
325				// Prevent never-ending loop
326				if ( target === copy ) {
327					continue;
328				}
329
330				// Recurse if we're merging plain objects or arrays
331				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
332					if ( copyIsArray ) {
333						copyIsArray = false;
334						clone = src && jQuery.isArray(src) ? src : [];
335
336					} else {
337						clone = src && jQuery.isPlainObject(src) ? src : {};
338					}
339
340					// Never move original objects, clone them
341					target[ name ] = jQuery.extend( deep, clone, copy );
342
343				// Don't bring in undefined values
344				} else if ( copy !== undefined ) {
345					target[ name ] = copy;
346				}
347			}
348		}
349	}
350
351	// Return the modified object
352	return target;
353};
354
355jQuery.extend({
356	noConflict: function( deep ) {
357		if ( window.$ === jQuery ) {
358			window.$ = _$;
359		}
360
361		if ( deep && window.jQuery === jQuery ) {
362			window.jQuery = _jQuery;
363		}
364
365		return jQuery;
366	},
367
368	// Is the DOM ready to be used? Set to true once it occurs.
369	isReady: false,
370
371	// A counter to track how many items to wait for before
372	// the ready event fires. See #6781
373	readyWait: 1,
374
375	// Hold (or release) the ready event
376	holdReady: function( hold ) {
377		if ( hold ) {
378			jQuery.readyWait++;
379		} else {
380			jQuery.ready( true );
381		}
382	},
383
384	// Handle when the DOM is ready
385	ready: function( wait ) {
386
387		// Abort if there are pending holds or we're already ready
388		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
389			return;
390		}
391
392		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
393		if ( !document.body ) {
394			return setTimeout( jQuery.ready, 1 );
395		}
396
397		// Remember that the DOM is ready
398		jQuery.isReady = true;
399
400		// If a normal DOM Ready event fired, decrement, and wait if need be
401		if ( wait !== true && --jQuery.readyWait > 0 ) {
402			return;
403		}
404
405		// If there are functions bound, to execute
406		readyList.resolveWith( document, [ jQuery ] );
407
408		// Trigger any bound ready events
409		if ( jQuery.fn.trigger ) {
410			jQuery( document ).trigger("ready").off("ready");
411		}
412	},
413
414	// See test/unit/core.js for details concerning isFunction.
415	// Since version 1.3, DOM methods and functions like alert
416	// aren't supported. They return false on IE (#2968).
417	isFunction: function( obj ) {
418		return jQuery.type(obj) === "function";
419	},
420
421	isArray: Array.isArray || function( obj ) {
422		return jQuery.type(obj) === "array";
423	},
424
425	isWindow: function( obj ) {
426		return obj != null && obj == obj.window;
427	},
428
429	isNumeric: function( obj ) {
430		return !isNaN( parseFloat(obj) ) && isFinite( obj );
431	},
432
433	type: function( obj ) {
434		return obj == null ?
435			String( obj ) :
436			class2type[ core_toString.call(obj) ] || "object";
437	},
438
439	isPlainObject: function( obj ) {
440		// Must be an Object.
441		// Because of IE, we also have to check the presence of the constructor property.
442		// Make sure that DOM nodes and window objects don't pass through, as well
443		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
444			return false;
445		}
446
447		try {
448			// Not own constructor property must be Object
449			if ( obj.constructor &&
450				!core_hasOwn.call(obj, "constructor") &&
451				!core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
452				return false;
453			}
454		} catch ( e ) {
455			// IE8,9 Will throw exceptions on certain host objects #9897
456			return false;
457		}
458
459		// Own properties are enumerated firstly, so to speed up,
460		// if last one is own, then all properties are own.
461
462		var key;
463		for ( key in obj ) {}
464
465		return key === undefined || core_hasOwn.call( obj, key );
466	},
467
468	isEmptyObject: function( obj ) {
469		var name;
470		for ( name in obj ) {
471			return false;
472		}
473		return true;
474	},
475
476	error: function( msg ) {
477		throw new Error( msg );
478	},
479
480	// data: string of html
481	// context (optional): If specified, the fragment will be created in this context, defaults to document
482	// scripts (optional): If true, will include scripts passed in the html string
483	parseHTML: function( data, context, scripts ) {
484		var parsed;
485		if ( !data || typeof data !== "string" ) {
486			return null;
487		}
488		if ( typeof context === "boolean" ) {
489			scripts = context;
490			context = 0;
491		}
492		context = context || document;
493
494		// Single tag
495		if ( (parsed = rsingleTag.exec( data )) ) {
496			return [ context.createElement( parsed[1] ) ];
497		}
498
499		parsed = jQuery.buildFragment( [ data ], context, scripts ? null : [] );
500		return jQuery.merge( [],
501			(parsed.cacheable ? jQuery.clone( parsed.fragment ) : parsed.fragment).childNodes );
502	},
503
504	parseJSON: function( data ) {
505		if ( !data || typeof data !== "string") {
506			return null;
507		}
508
509		// Make sure leading/trailing whitespace is removed (IE can't handle it)
510		data = jQuery.trim( data );
511
512		// Attempt to parse using the native JSON parser first
513		if ( window.JSON && window.JSON.parse ) {
514			return window.JSON.parse( data );
515		}
516
517		// Make sure the incoming data is actual JSON
518		// Logic borrowed from http://json.org/json2.js
519		if ( rvalidchars.test( data.replace( rvalidescape, "@" )
520			.replace( rvalidtokens, "]" )
521			.replace( rvalidbraces, "")) ) {
522
523			return ( new Function( "return " + data ) )();
524
525		}
526		jQuery.error( "Invalid JSON: " + data );
527	},
528
529	// Cross-browser xml parsing
530	parseXML: function( data ) {
531		var xml, tmp;
532		if ( !data || typeof data !== "string" ) {
533			return null;
534		}
535		try {
536			if ( window.DOMParser ) { // Standard
537				tmp = new DOMParser();
538				xml = tmp.parseFromString( data , "text/xml" );
539			} else { // IE
540				xml = new ActiveXObject( "Microsoft.XMLDOM" );
541				xml.async = "false";
542				xml.loadXML( data );
543			}
544		} catch( e ) {
545			xml = undefined;
546		}
547		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
548			jQuery.error( "Invalid XML: " + data );
549		}
550		return xml;
551	},
552
553	noop: function() {},
554
555	// Evaluates a script in a global context
556	// Workarounds based on findings by Jim Driscoll
557	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
558	globalEval: function( data ) {
559		if ( data && core_rnotwhite.test( data ) ) {
560			// We use execScript on Internet Explorer
561			// We use an anonymous function so that context is window
562			// rather than jQuery in Firefox
563			( window.execScript || function( data ) {
564				window[ "eval" ].call( window, data );
565			} )( data );
566		}
567	},
568
569	// Convert dashed to camelCase; used by the css and data modules
570	// Microsoft forgot to hump their vendor prefix (#9572)
571	camelCase: function( string ) {
572		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
573	},
574
575	nodeName: function( elem, name ) {
576		return elem.nodeName && elem.nodeName.to

576UpperCase() === name.toUpperCase();
577	},
578
579	// args is for internal usage only
580	each: function( obj, callback, args ) {
581		var name,
582			i = 0,
583			length = obj.length,
584			isObj = length === undefined || jQuery.isFunction( obj );
585
586		if ( args ) {
587			if ( isObj ) {
588				for ( name in obj ) {
589					if ( callback.apply( obj[ name ], args ) === false ) {
590						break;
591					}
592				}
593			} else {
594				for ( ; i < length; ) {
595					if ( callback.apply( obj[ i++ ], args ) === false ) {
596						break;
597					}
598				}
599			}
600
601		// A special, fast, case for the most common use of each
602		} else {
603			if ( isObj ) {
604				for ( name in obj ) {
605					if ( callback.call( obj[ name ], name, obj[ name ] ) === false ) {
606						break;
607					}
608				}
609			} else {
610				for ( ; i < length; ) {
611					if ( callback.call( obj[ i ], i, obj[ i++ ] ) === false ) {
612						break;
613					}
614				}
615			}
616		}
617
618		return obj;
619	},
620
621	// Use native String.trim function wherever possible
622	trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
623		function( text ) {
624			return text == null ?
625				"" :
626				core_trim.call( text );
627		} :
628
629		// Otherwise use our own trimming functionality
630		function( text ) {
631			return text == null ?
632				"" :
633				text.toString().replace( rtrim, "" );
634		},
635
636	// results is for internal usage only
637	makeArray: function( arr, results ) {
638		var type,
639			ret = results || [];
640
641		if ( arr != null ) {
642			// The window, strings (and functions) also have 'length'
643			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
644			type = jQuery.type( arr );
645
646			if ( arr.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( arr ) ) {
647				core_push.call( ret, arr );
648			} else {
649				jQuery.merge( ret, arr );
650			}
651		}
652
653		return ret;
654	},
655
656	inArray: function( elem, arr, i ) {
657		var len;
658
659		if ( arr ) {
660			if ( core_indexOf ) {
661				return core_indexOf.call( arr, elem, i );
662			}
663
664			len = arr.length;
665			i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
666
667			for ( ; i < len; i++ ) {
668				// Skip accessing in sparse arrays
669				if ( i in arr && arr[ i ] === elem ) {
670					return i;
671				}
672			}
673		}
674
675		return -1;
676	},
677
678	merge: function( first, second ) {
679		var l = second.length,
680			i = first.length,
681			j = 0;
682
683		if ( typeof l === "number" ) {
684			for ( ; j < l; j++ ) {
685				first[ i++ ] = second[ j ];
686			}
687
688		} else {
689			while ( second[j] !== undefined ) {
690				first[ i++ ] = second[ j++ ];
691			}
692		}
693
694		first.length = i;
695
696		return first;
697	},
698
699	grep: function( elems, callback, inv ) {
700		var retVal,
701			ret = [],
702			i = 0,
703			length = elems.length;
704		inv = !!inv;
705
706		// Go through the array, only saving the items
707		// that pass the validator function
708		for ( ; i < length; i++ ) {
709			retVal = !!callback( elems[ i ], i );
710			if ( inv !== retVal ) {
711				ret.push( elems[ i ] );
712			}
713		}
714
715		return ret;
716	},
717
718	// arg is for internal usage only
719	map: function( elems, callback, arg ) {
720		var value, key,
721			ret = [],
722			i = 0,
723			length = elems.length,
724			// jquery objects are treated as arrays
725			isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
726
727		// Go through the array, translating each of the items to their
728		if ( isArray ) {
729			for ( ; i < length; i++ ) {
730				value = callback( elems[ i ], i, arg );
731
732				if ( value != null ) {
733					ret[ ret.length ] = value;
734				}
735			}
736
737		// Go through every key on the object,
738		} else {
739			for ( key in elems ) {
740				value = callback( elems[ key ], key, arg );
741
742				if ( value != null ) {
743					ret[ ret.length ] = value;
744				}
745			}
746		}
747
748		// Flatten any nested arrays
749		return ret.concat.apply( [], ret );
750	},
751
752	// A global GUID counter for objects
753	guid: 1,
754
755	// Bind a function to a context, optionally partially applying any
756	// arguments.
757	proxy: function( fn, context ) {
758		var tmp, args, proxy;
759
760		if ( typeof context === "string" ) {
761			tmp = fn[ context ];
762			context = fn;
763			fn = tmp;
764		}
765
766		// Quick check to determine if target is callable, in the spec
767		// this throws a TypeError, but we will just return undefined.
768		if ( !jQuery.isFunction( fn ) ) {
769			return undefined;
770		}
771
772		// Simulated bind
773		args = core_slice.call( arguments, 2 );
774		proxy = function() {
775			return fn.apply( context, args.concat( core_slice.call( arguments ) ) );
776		};
777
778		// Set the guid of unique handler to the same of original handler, so it can be removed
779		proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
780
781		return proxy;
782	},
783
784	// Multifunctional method to get and set values of a collection
785	// The value/s can optionally be executed if it's a function
786	access: function( elems, fn, key, value, chainable, emptyGet, pass ) {
787		var exec,
788			bulk = key == null,
789			i = 0,
790			length = elems.length;
791
792		// Sets many values
793		if ( key && typeof key === "object" ) {
794			for ( i in key ) {
795				jQuery.access( elems, fn, i, key[i], 1, emptyGet, value );
796			}
797			chainable = 1;
798
799		// Sets one value
800		} else if ( value !== undefined ) {
801			// Optionally, function values get executed if exec is true
802			exec = pass === undefined && jQuery.isFunction( value );
803
804			if ( bulk ) {
805				// Bulk operations only iterate when executing function values
806				if ( exec ) {
807					exec = fn;
808					fn = function( elem, key, value ) {
809						return exec.call( jQuery( elem ), value );
810					};
811
812				// Otherwise they run against the entire set
813				} else {
814					fn.call( elems, value );
815					fn = null;
816				}
817			}
818
819			if ( fn ) {
820				for (; i < length; i++ ) {
821					fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
822				}
823			}
824
825			chainable = 1;
826		}
827
828		return chainable ?
829			elems :
830
831			// Gets
832			bulk ?
833				fn.call( elems ) :
834				length ? fn( elems[0], key ) : emptyGet;
835	},
836
837	now: function() {
838		return ( new Date() ).getTime();
839	}
840});
841
842jQuery.ready.promise = function( obj ) {
843	if ( !readyList ) {
844
845		readyList = jQuery.Deferred();
846
847		// Catch cases where $(document).ready() is called after the browser event has already occurred.
848		// we once tried to use readyState "interactive" here, but it caused issues like the one
849		// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
850		if ( document.readyState === "complete" ) {
851			// Handle it asynchronously to allow scripts the opportunity to delay ready
852			setTimeout( jQuery.ready, 1 );
853
854		// Standards-based browsers support DOMContentLoaded
855		} else if ( document.addEventListener ) {
856			// Use the handy event callback
857			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
858
859			// A fallback to window.onload, that will always work
860			window.addEventListener( "load", jQuery.ready, false );
861
862		// If IE event model is used
863		} else {
864			// Ensure firing before onload, maybe late but safe also for iframes
865			document.attachEvent( "onreadystatechange", DOMContentLoaded );
866
867			// A fallback to window.onload, that will always work
868			window.attachEvent( "onload", jQuery.ready );
869
870			// If IE and not a frame
871			// continually check to see if the document is ready
872			var top = false;
873
874			try {
875				top = window.frameElement == null && document.documentElement;
876			} catch(e) {}
877
878			if ( top && top.doScroll ) {
879				(function doScrollCheck() {
880					if ( !jQuery.isReady ) {
881
882						try {
883							// Use the trick by Diego Perini
884							// http://javascript.nwbox.com/IEContentLoaded/
885							top.doScroll("left");
886						} catch(e) {
887							return setTimeout( doScrollCheck, 50 );
888						}
889
890						// and execute any waiting functions
891						jQuery.ready();
892					}
893				})();
894			}
895		}
896	}
897	return readyList.promise( obj );
898};
899
900// Populate the class2type map
901jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
902	class2type[ "[object " + name + "]" ] = name.toLowerCase();
903});
904
905// All jQuery objects should point back to these
906rootjQuery = jQuery(document);
907// String to Object options format cache
908var optionsCache = {};
909
910// Convert String-formatted options into Object-formatted ones and store in cache
911function createOptions( options ) {
912	var object = optionsCache[ options ] = {};
913	jQuery.each( options.split( core_rspace ), function( _, flag ) {
914		object[ flag ] = true;
915	});
916	return object;
917}
918
919/*
920 * Create a callback list using the following parameters:
921 *
922 *	options: an optional list of space-separated options that will change how
923 *			the callback list behaves or a more traditional option object
924 *
925 * By default a callback list will act like an event callback list and can be
926 * "fired" multiple times.
927 *
928 * Possible options:
929 *
930 *	once:			will ensure the callback list can only be fired once (like a Deferred)
931 *
932 *	memory:			will keep track of previous values and will call any callback added
933 *					after the list has been fired right away with the latest "memorized"
934 *					values (like a Deferred)
935 *
936 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
937 *
938 *	stopOnFalse:	interrupt callings when a callback returns false
939 *
940 */
941jQuery.Callbacks = function( options ) {
942
943	// Convert options from String-formatted to Object-formatted if needed
944	// (we check in cache first)
945	options = typeof options === "string" ?
946		( optionsCache[ options ] || createOptions( options ) ) :
947		jQuery.extend( {}, options );
948
949	var // Last fire value (for non-forgettable lists)
950		memory,
951		// Flag to know if list was already fired
952		fired,
953		// Flag to know if list is currently firing
954		firing,
955		// First callback to fire (used internally by add and fireWith)
956		firingStart,
957		// End of the loop when firing
958		firingLength,
959		// Index of currently firing callback (modified by remove if needed)
960		firingIndex,
961		// Actual callback list
962		list = [],
963		// Stack of fire calls for repeatable lists
964		stack = !options.once && [],
965		// Fire callbacks
966		fire = function( data ) {
967			memory = options.memory && data;
968			fired = true;
969			firingIndex = firingStart || 0;
970			firingStart = 0;
971			firingLength = list.length;
972			firing = true;
973			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
974				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
975					memory = false; // To prevent further calls using add
976					break;
977				}
978			}
979			firing = false;
980			if ( list ) {
981				if ( stack ) {
982					if ( stack.length ) {
983						fire( stack.shift() );
984					}
985				} else if ( memory ) {
986					list = [];
987				} else {
988					self.disable();
989				}
990			}
991		},
992		// Actual Callbacks object
993		self = {
994			// Add a callback or a collection of callbacks to the list
995			add: function() {
996				if ( list ) {
997					// First, we save the current length
998					var start = list.length;
999					(function add( args ) {
1000						jQuery.each( args, function( _, arg ) {
1001							var type = jQuery.type( arg );
1002							if ( type === "function" && ( !options.unique || !self.has( arg ) ) ) {
1003								list.push( arg );
1004							} else if ( arg && arg.length && type !== "string" ) {
1005								// Inspect recursively
1006								add( arg );
1007							}
1008						});
1009					})( arguments );
1010					// Do we need to add the callbacks to the
1011					// current firing batch?
1012					if ( firing ) {
1013						firingLength = list.length;
1014					// With memory, if we're not firing then
1015					// we should call right away
1016					} else if ( memory ) {
1017						firingStart = start;
1018						fire( memory );
1019					}
1020				}
1021				return this;
1022			},
1023			// Remove a callback from the list
1024			remove: function() {
1025				if ( list ) {
1026					jQuery.each( arguments, function( _, arg ) {
1027						var index;
1028						while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
1029							list.splice( index, 1 );
1030							// Handle firing indexes
1031							if ( firing ) {
1032								if ( index <= firingLength ) {
1033									firingLength--;
1034								}
1035								if ( index <= firingIndex ) {
1036									firingIndex--;
1037								}
1038							}
1039						}
1040					});
1041				}
1042				return this;
1043			},
1044			// Control if a given callback is in the list
1045			has: function( fn ) {
1046				return jQuery.inArray( fn, list ) > -1;
1047			},
1048			// Remove all callbacks from the list
1049			empty: function() {
1050				list = [];
1051				return this;
1052			},
1053			// Have the list do nothing anymore
1054			disable: function() {
1055				list = stack = memory = undefined;
1056				return this;
1057			},
1058			// Is it disabled?
1059			disabled: function() {
1060				return !list;
1061			},
1062			// Lock the list in its current state
1063			lock: function() {
1064				stack = undefined;
1065				if ( !memory ) {
1066					self.disable();
1067				}
1068				return this;
1069			},
1070			// Is it locked?
1071			locked: function() {
1072				return !stack;
1073			},
1074			// Call all callbacks with the given context and arguments
1075			fireWith: function( context, args ) {
1076				args = args || [];
1077				args = [ context, args.slice ? args.slice() : args ];
1078				if ( list && ( !fired || stack ) ) {
1079					if ( firing ) {
1080						stack.push( args );
1081					} else {
1082						fire( args );
1083					}
1084				}
1085				return this;
1086			},
1087			// Call all the callbacks with the given arguments
1088			fire: function() {
1089				self.fireWith( this, arguments );
1090				return this;
1091			},
1092			// To know if the callbacks have already been called at least once
1093			fired: function() {
1094				return !!fired;
1095			}
1096		};
1097
1098	return self;
1099};
1100jQuery.extend({
1101
1102	Deferred: function( func ) {
1103		var tuples = [
1104				// action, add listener, listener list, final state
1105				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
1106				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
1107				[ "notify", "progress", jQuery.Callbacks("memory") ]
1108			],
1109			state = "pending",
1110			promise = {
1111				state: function() {
1112					return state;
1113				},
1114				always: function() {
1115					deferred.done( arguments ).fail( arguments );
1116					return this;
1117				},
1118				then: function( /* fnDone, fnFail, fnProgress */ ) {
1119					var fns = arguments;
1120					return jQuery.Deferred(function( newDefer ) {
1121						jQuery.each( tuples, function( i, tuple ) {
1122							var action = tuple[ 0 ],
1123								fn = fns[ i ];
1124							// deferred[ done | fail | progress ] for forwarding actions to newDefer
1125							deferred[ tuple[1] ]( jQuery.isFunction( fn ) ?
1126								function() {
1127									var returned = fn.apply( this, arguments );
1128									if ( returned && jQuery.isFunction( returned.promise ) ) {
1129										returned.promise()
1130											.done( newDefer.resolve )
1131											.fail( newDefer.reject )
1132											.progress( newDefer.notify );
1133									} else {
1134										newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
1135									}
1136								} :
1137								newDefer[ action ]
1138							);
1139						});
1140						fns = null;
1141					}).promise();
1142				},
1143				// Get a promise for this deferred
1144				// If obj is provided, the promise aspect is added to the object
1145				promise: function( obj ) {
1146					return typeof obj === "object" ? jQuery.extend( obj, promise ) : promise;
1147				}
1148			},
1149			deferred = {};
1150
1151		// Keep pipe for back-compat
1152		promise.pipe = promise.then;
1153
1154		// Add list-specific methods
1155		jQuery.each( tuples, function( i, tuple ) {
1156			var list = tuple[ 2 ],
1157				stateString = tuple[ 3 ];
1158
1159			// promise[ done | fail | progress ] = list.add
1160			promise[ tuple[1] ] = list.add;
1161
1162			// Handle state
1163			if ( stateString ) {
1164				list.add(function() {
1165					// state = [ resolved | rejected ]
1166					state = stateString;
1167
1168				// [ reject_list | resolve_list ].disable; progress_list.lock
1169				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
1170			}
1171
1172			// deferred[ resolve | reject | notify ] = list.fire
1173			deferred[ tuple[0] ] = list.fire;
1174			deferred[ tuple[0] + "With" ] = list.fireWith;
1175		});
1176
1177		// Make the deferred a promise
1178		promise.promise( deferred );
1179
1180		// Call given func if any
1181		if ( func ) {
1182			func.call( deferred, deferred );
1183		}
1184
1185		// All done!
1186		return deferred;
1187	},
1188
1189	// Deferred helper
1190	when: function( subordinate /* , ..., subordinateN */ ) {
1191		var i = 0,
1192			resolveValues = core_slice.call( arguments ),
1193			length = resolveValues.length,
1194
1195			// the count of uncompleted subordinates
1196			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
1197
1198			// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
1199			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
1200
1201			// Update function for both resolve and progress values
1202			updateFunc = function( i, contexts, values ) {
1203				return function( value ) {
1204					contexts[ i ] = this;
1205					values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
1206					if( values === progressValues ) {
1207						deferred.notifyWith( contexts, values );
1208					} else if ( !( --remaining ) ) {
1209						deferred.resolveWith( contexts, values );
1210					}
1211				};
1212			},
1213
1214			progressValues, progressContexts, resolveContexts;
1215
1216		// add listeners to Deferred subordinates; treat others as resolved
1217		if ( length > 1 ) {
1218			progressValues = new Array( length );
1219			progressContexts = new Array( length );
1220			resolveContexts = new Array( length );
1221			for ( ; i < length; i++ ) {
1222				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
1223					resolveValues[ i ].promise()
1224						.done( updateFunc( i, resolveContexts, resolveValues ) )
1225						.fail( deferred.reject )
1226						.progress( updateFunc( i, progressContexts, progressValues ) );
1227				} else {
1228					--remaining;
1229				}
1230			}
1231		}
1232
1233		// if we're not waiting on anything, resolve the master
1234		if ( !remaining ) {
1235			deferred.resolveWith( resolveContexts, resolveValues );
1236		}
1237
1238		return deferred.promise();
1239	}
1240});
1241jQuery.support = (function() {
1242
1243	var support,
1244		all,
1245		a,
1246		select,
1247		opt,
1248		input,
1249		fragment,
1250		eventName,
1251		i,
1252		isSupported,
1253		clickFn,
1254		div = document.createElement("div");
1255
1256	// Preliminary tests
1257	div.setAttribute( "className", "t" );
1258	div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
1259
1260	all = div.getElementsByTagName("*");
1261	a = div.getElementsByTagName("a")[ 0 ];
1262	a.style.cssText = "top:1px;float:left;opacity:.5";
1263
1264	// Can't get basic test support
1265	if ( !all || !all.length || !a ) {
1266		return {};
1267	}
1268
1269	// First batch of supports tests
1270	select = document.createElement("select");
1271	opt = select.appendChild( document.createElement("option") );
1272	input = div.getElementsByTagName("input")[ 0 ];
1273
1274	support = {
1275		// IE strips leading whitespace when .innerHTML is used
1276		leadingWhitespace: ( div.firstChild.nodeType === 3 ),
1277
1278		// Make sure that tbody elements aren't automatically inserted
1279		// IE will insert them into empty tables
1280		tbody: !div.getElementsByTagName("tbody").length,
1281
1282		// Make sure that link elements get serialized correctly by innerHTML
1283		// This requires a wrapper element in IE
1284		htmlSerialize: !!div.getElementsByTagName("link").length,
1285
1286		// Get the style information from getAttribute
1287		// (IE uses .cssText instead)
1288		style: /top/.test( a.getAttribute("style") ),
1289
1290		// Make sure that URLs aren't manipulated
1291		// (IE normalizes it by default)
1292		hrefNormalized: ( a.getAttribute("href") === "/a" ),
1293
1294		// Make sure that element opacity exists
1295		// (IE uses filter instead)
1296		// Use a regex to work around a WebKit issue. See #5145
1297		opacity: /^0.5/.test( a.style.opacity ),
1298
1299		// Verify style float existence
1300		// (IE uses styleFloat instead of cssFloat)
1301		cssFloat: !!a.style.cssFloat,
1302
1303		// Make sure that if no value is specified for a checkbox
1304		// that it defaults to "on".
1305		// (WebKit defaults to "" instead)
1306		checkOn: ( input.value === "on" ),
1307
1308		// Make sure that a selected-by-default option has a working selected property.
1309		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1310		optSelected: opt.selected,
1311
1312		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1313		getSetAttribute: div.className !== "t",
1314
1315		// Tests for enctype support on a form(#6743)
1316		enctype: !!document.createElement("form").enctype,
1317
1318		// Makes sure cloning an html5 element does not cause problems
1319		// Where outerHTML is undefined, this still works
1320		html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
1321
1322		// jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
1323		boxModel: ( document.compatMode === "CSS1Compat" ),
1324
1325		// Will be defined later
1326		submitBubbles: true,
1327		changeBubbles: true,
1328		focusinBubbles: false,
1329		deleteExpando: true,
1330		noCloneEvent: true,
1331		inlineBlockNeedsLayout: false,
1332		shrinkWrapBlocks: false,
1333		reliableMarginRight: true,
1334		boxSizingReliable: true,
1335		pixelPosition: false
1336	};
1337
1338	// Make sure checked status is properly cloned
1339	input.checked = true;
1340	support.noCloneChecked = input.cloneNode( true ).checked;
1341
1342	// Make sure that the options inside disabled selects aren't marked as disabled
1343	// (WebKit marks them as disabled)
1344	select.disabled = true;
1345	support.optDisabled = !opt.disabled;
1346
1347	// Test to see if it's possible to delete an expando from an element
1348	// Fails in Internet Explorer
1349	try {
1350		delete div.test;
1351	} catch( e ) {
1352		support.deleteExpando = false;
1353	}
1354
1355	if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1356		div.attachEvent( "onclick", clickFn = function() {
1357			// Cloning a node shouldn't copy over any
1358			// bound event handlers (IE does this)
1359			support.noCloneEvent = false;
1360		});
1361		div.cloneNode( true ).fireEvent("onclick");
1362		div.detachEvent( "onclick", clickFn );
1363	}
1364
1365	// Check if a radio maintains its value
1366	// after being appended to the DOM
1367	input = document.createElement("input");
1368	input.value = "t";
1369	input.setAttribute( "type", "radio" );
1370	support.radioValue = input.value === "t";
1371
1372	input.setAttribute( "checked", "checked" );
1373
1374	// #11217 - WebKit loses check when the name is after the checked attribute
1375	input.setAttribute( "name", "t" );
1376
1377	div.appendChild( input );
1378	fragment = document.createDocumentFragment();
1379	fragment.appendChild( div.lastChild );
1380
1381	// WebKit doesn't clone checked state correctly in fragments
1382	support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
1383
1384	// Check if a disconnected checkbox will retain its checked
1385	// value of true after appended to the DOM (IE6/7)
1386	support.appendChecked = input.checked;
1387
1388	fragment.removeChild( input );
1389	fragment.appendChild( div );
1390
1391	// Technique from Juriy Zaytsev
1392	// http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
1393	// We only care about the case where non-standard event systems
1394	// are used, namely in IE. Short-circuiting here helps us to
1395	// avoid an eval call (in setAttribute) which can cause CSP
1396	// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1397	if ( div.attachEvent ) {
1398		for ( i in {
1399			submit: true,
1400			change: true,
1401			focusin: true
1402		}) {
1403			eventName = "on" + i;
1404			isSupported = ( eventName in div );
1405			if ( !isSupported ) {
1406				div.setAttribute( eventName, "return;" );
1407				isSupported = ( typeof div[ eventName ] === "function" );
1408			}
1409			support[ i + "Bubbles" ] = isSupported;
1410		}
1411	}
1412
1413	// Run tests that need a body at doc ready
1414	jQuery(function() {
1415		var container, div, tds, marginDiv,
1416			divReset = "padding:0;margin:0;border:0;display:block;overflow:hidden;",
1417			body = document.getElementsByTagName("body")[0];
1418
1419		if ( !body ) {
1420			// Return for frameset docs that don't have a body
1421			return;
1422		}
1423
1424		container = document.createElement("div");
1425		container.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px";
1426		body.insertBefore( container, body.firstChild );
1427
1428		// Construct the test element
1429		div = document.createElement("div");
1430		container.appendChild( div );
1431
1432		// Check if table cells still have offsetWidth/Height when they are set
1433		// to display:none and there are still other visible table cells in a
1434		// table row; if so, offsetWidth/Height are not reliable for use when
1435		// determining if an element has been hidden directly using
1436		// display:none (it is still safe to use offsets if a parent element is
1437		// hidden; don safety goggles and see bug #4512 for more information).
1438		// (only IE 8 fails this test)
1439		div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
1440		tds = div.getElementsByTagName("td");
1441		tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
1442		isSupported = ( tds[ 0 ].offsetHeight === 0 );
1443
1444		tds[ 0 ].style.display = "";
1445		tds[ 1 ].style.display = "none";
1446
1447		// Check if empty table cells still have offsetWidth/Height
1448		// (IE <= 8 fail this test)
1449		support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1450
1451		// Check box-sizing and margin behavior
1452		div.innerHTML = "";
1453		div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
1454		support.boxSizing = ( div.offsetWidth === 4 );
1455		support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
1456
1457		// NOTE: To any future maintainer, we've window.getComputedStyle
1458		// because jsdom on node.js will break without it.
1459		if ( window.getComputedStyle ) {
1460			support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
1461			support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
1462
1463			// Check if div with explicit width and no margin-right incorrectly
1464			// gets computed margin-right based on width of container. For more
1465			// info see bug #3333
1466			// Fails in WebKit before Feb 2011 nightlies
1467			// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1468			marginDiv = document.createElement("div");
1469			marginDiv.style.cssText = div.style.cssText = divReset;
1470			marginDiv.style.marginRight = marginDiv.style.width = "0";
1471			div.style.width = "1px";
1472			div.appendChild( marginDiv );
1473			support.reliableMarginRight =
1474				!parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
1475		}
1476
1477		if ( typeof div.style.zoom !== "undefined" ) {
1478			// Check if natively block-level elements act like inline-block
1479			// elements when setting their display to 'inline' and giving
1480			// them layout
1481			// (IE < 8 does this)
1482			div.innerHTML = "";
1483			div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
1484			support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
1485
1486			// Check if elements with layout shrink-wrap their children
1487			// (IE 6 does this)
1488			div.style.display = "block";
1489			div.style.overflow = "visible";
1490			div.innerHTML = "<div></div>";
1491			div.firstChild.style.width = "5px";
1492			support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
1493
1494			container.style.zoom = 1;
1495		}
1496
1497		// Null elements to avoid leaks in IE
1498		body.removeChild( container );
1499		container = div = tds = marginDiv = null;
1500	});
1501
1502	// Null elements to avoid leaks in IE
1503	fragment.removeChild( div );
1504	all = a = select = opt = input = fragment = div = null;
1505
1506	return support;
1507})();
1508var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
1509	rmultiDash = /([A-Z])/g;
1510
1511jQuery.extend({
1512	cache: {},
1513
1514	deletedIds: [],
1515
1516	// Please use with caution
1517	uuid: 0,
1518
1519	// Unique for each copy of jQuery on the page
1520	// Non-digits removed to match rinlinejQuery
1521	expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1522
1523	// The following elements throw uncatchable exceptions if you
1524	// attempt to add expando properties to them.
1525	noData: {
1526		"embed": true,
1527		// Ban all objects except for Flash (which handle expandos)
1528		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1529		"applet": true
1530	},
1531
1532	hasData: function( elem ) {
1533		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1534		return !!elem && !isEmptyDataObject( elem );
1535	},
1536
1537	data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1538		if ( !jQuery.acceptData( elem ) ) {
1539			return;
1540		}
1541
1542		var thisCache, ret,
1543			internalKey = jQuery.expando,
1544			getByName = typeof name === "string",
1545
1546			// We have to handle DOM nodes and JS objects differently because IE6-7
1547			// can't GC object references properly across the DOM-JS boundary
1548			isNode = elem.nodeType,
1549
1550			// Only DOM nodes need the global jQuery cache; JS object data is
1551			// attached directly to the object so GC can occur automatically
1552			cache = isNode ? jQuery.cache : elem,
1553
1554			// Only defining an ID for JS objects if its cache already exists allows
1555			// the code to shortcut on the same path as a DOM node with no cache
1556			id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
1557
1558		// Avoid doing any more work than we need to when trying to get data on an
1559		// object that has no data at all
1560		if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) {
1561			return;
1562		}
1563
1564		if ( !id ) {
1565			// Only DOM nodes need a new unique ID for each element since their data
1566			// ends up in the global cache
1567			if ( isNode ) {
1568				elem[ internalKey ] = id = jQuery.deletedIds.pop() || ++jQuery.uuid;
1569			} else {
1570				id = internalKey;
1571			}
1572		}
1573
1574		if ( !cache[ id ] ) {
1575			cache[ id ] = {};
1576
1577			// Avoids exposing jQuery metadata on plain JS objects when the object
1578			// is serialized using JSON.stringify
1579			if ( !isNode ) {
1580				cache[ id ].toJSON = jQuery.noop;
1581			}
1582		}
1583
1584		// An object can be passed to jQuery.data instead of a key/value pair; this gets
1585		// shallow copied over onto the existing cache
1586		if ( typeof name === "object" || typeof name === "function" ) {
1587			if ( pvt ) {
1588				cache[ id ] = jQuery.extend( cache[ id ], name );
1589			} else {
1590				cache[ id ].data = jQuery.extend( cache[ id ].data, name );
1591			}
1592		}
1593
1594		thisCache = cache[ id ];
1595
1596		// jQuery data() is stored in a separate object inside the object's internal data
1597		// cache in order to avoid key collisions between internal data and user-defined
1598		// data.
1599		if ( !pvt ) {
1600			if ( !thisCache.data ) {
1601				thisCache.data = {};
1602			}
1603
1604			thisCache = thisCache.data;
1605		}
1606
1607		if ( data !== undefined ) {
1608			thisCache[ jQuery.camelCase( name ) ] = data;
1609		}
1610
1611		// Check for both converted-to-camel and non-converted data property names
1612		// If a data property was specified
1613		if ( getByName ) {
1614
1615			// First Try to find as-is property data
1616			ret = thisCache[ name ];
1617
1618			// Test for null|undefined property data
1619			if ( ret == null ) {
1620
1621				// Try to find the camelCased property
1622				ret = thisCache[ jQuery.camelCase( name ) ];
1623			}
1624		} else {
1625			ret = thisCache;
1626		}
1627
1628		return ret;
1629	},
1630
1631	removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1632		if ( !jQuery.acceptData( elem ) ) {
1633			return;
1634		}
1635
1636		var thisCache, i, l,
1637
1638			isNode = elem.nodeType,
1639
1640			// See jQuery.data for more information
1641			cache = isNode ? jQuery.cache : elem,
1642			id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
1643
1644		// If there is already no cache entry for this object, there is no
1645		// purpose in continuing
1646		if ( !cache[ id ] ) {
1647			return;
1648		}
1649
1650		if ( name ) {
1651
1652			thisCache = pvt ? cache[ id ] : cache[ id ].data;
1653
1654			if ( thisCache ) {
1655
1656				// Support array or space separated string names for data keys
1657				if ( !jQuery.isArray( name ) ) {
1658
1659					// try the string as a key before any manipulation
1660					if ( name in thisCache ) {
1661						name = [ name ];
1662					} else {
1663
1664						// split the camel cased version by spaces unless a key with the spaces exists
1665						name = jQuery.camelCase( name );
1666						if ( name in thisCache ) {
1667							name = [ name ];
1668						} else {
1669							name = name.split(" ");
1670						}
1671					}
1672				}
1673
1674				for ( i = 0, l = name.length; i < l; i++ ) {
1675					delete thisCache[ name[i] ];
1676				}
1677
1678				// If there is no data left in the cache, we want to continue
1679				// and let the cache object itself get destroyed
1680				if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
1681					return;
1682				}
1683			}
1684		}
1685
1686		// See jQuery.data for more information
1687		if ( !pvt ) {
1688			delete cache[ id ].data;
1689
1690			// Don't destroy the parent cache unless the internal data object
1691			// had been the only thing left in it
1692			if ( !isEmptyDataObject( cache[ id ] ) ) {
1693				return;
1694			}
1695		}
1696
1697		// Destroy the cache
1698		if ( isNode ) {
1699			jQuery.cleanData( [ elem ], true );
1700
1701		// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
1702		} else if ( jQuery.support.deleteExpando || cache != cache.window ) {
1703			delete cache[ id ];
1704
1705		// When all else fails, null
1706		} else {
1707			cache[ id ] = null;
1708		}
1709	},
1710
1711	// For internal use only.
1712	_data: function( elem, name, data ) {
1713		return jQuery.data( elem, name, data, true );
1714	},
1715
1716	// A method for determining if a DOM node can handle the data expando
1717	acceptData: function( elem ) {
1718		var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];
1719
1720		// nodes accept data unless otherwise specified; rejection can be conditional
1721		return !noData || noData !== true && elem.getAttribute("classid") === noData;
1722	}
1723});
1724
1725jQuery.fn.extend({
1726	data: function( key, value ) {
1727		var parts, part, attr, name, l,
1728			elem = this[0],
1729			i = 0,
1730			data = null;
1731
1732		// Gets all values
1733		if ( key === undefined ) {
1734			if ( this.length ) {
1735				data = jQuery.data( elem );
1736
1737				if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
1738					attr = elem.attributes;
1739					for ( l = attr.length; i < l; i++ ) {
1740						name = attr[i].name;
1741
1742						if ( name.indexOf( "data-" ) === 0 ) {
1743							name = jQuery.camelCase( name.substring(5) );
1744
1745							dataAttr( elem, name, data[ name ] );
1746						}
1747					}
1748					jQuery._data( elem, "parsedAttrs", true );
1749				}
1750			}
1751
1752			return data;
1753		}
1754
1755		// Sets multiple values
1756		if ( typeof key === "object" ) {
1757			return this.each(function() {
1758				jQuery.data( this, key );
1759			});
1760		}
1761
1762		parts = key.split( ".", 2 );
1763		parts[1] = parts[1] ? "." + parts[1] : "";
1764		part = parts[1] + "!";
1765
1766		return jQuery.access( this, function( value ) {
1767
1768			if ( value === undefined ) {
1769				data = this.triggerHandler( "getData" + part, [ parts[0] ] );
1770
1771				// Try to fetch any internally stored data first
1772				if ( data === undefined && elem ) {
1773					data = jQuery.data( elem, key );
1774					data = dataAttr( elem, key, data );
1775				}
1776
1777				return data === undefined && parts[1] ?
1778					this.data( parts[0] ) :
1779					data;
1780			}
1781
1782			parts[1] = value;
1783			this.each(function() {
1784				var self = jQuery( this );
1785
1786				self.triggerHandler( "setData" + part, parts );
1787				jQuery.data( this, key, value );
1788				self.triggerHandler( "changeData" + part, parts );
1789			});
1790		}, null, value, arguments.length > 1, null, false );
1791	},
1792
1793	removeData: function( key ) {
1794		return this.each(function() {
1795			jQuery.removeData( this, key );
1796		});
1797	}
1798});
1799
1800function dataAttr( elem, key, data ) {
1801	// If nothing was found internally, try to fetch any
1802	// data from the HTML5 data-* attribute
1803	if ( data === undefined && elem.nodeType === 1 ) {
1804
1805		var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
1806
1807		data = elem.getAttribute( name );
1808
1809		if ( typeof data === "string" ) {
1810			try {
1811				data = data === "true" ? true :
1812				data === "false" ? false :
1813				data === "null" ? null :
1814				// Only convert to a number if it doesn't change the string
1815				+data + "" === data ? +data :
1816				rbrace.test( data ) ? jQuery.parseJSON( data ) :
1817					data;
1818			} catch( e ) {}
1819
1820			// Make sure we set the data so it isn't changed later
1821			jQuery.data( elem, key, data );
1822
1823		} else {
1824			data = undefined;
1825		}
1826	}
1827
1828	return data;
1829}
1830
1831// checks a cache object for emptiness
1832function isEmptyDataObject( obj ) {
1833	var name;
1834	for ( name in obj ) {
1835
1836		// if the public data object is empty, the private is still empty
1837		if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
1838			continue;
1839		}
1840		if ( name !== "toJSON" ) {
1841			return false;
1842		}
1843	}
1844
1845	return true;
1846}
1847jQuery.extend({
1848	queue: function( elem, type, data ) {
1849		var queue;
1850
1851		if ( elem ) {
1852			type = ( type || "fx" ) + "queue";
1853			queue = jQuery._data( elem, type );
1854
1855			// Speed up dequeue by getting out quickly if this is just a lookup
1856			if ( data ) {
1857				if ( !queue || jQuery.isArray(data) ) {
1858					queue = jQuery._data( elem, type, jQuery.makeArray(data) );
1859				} else {
1860					queue.push( data );
1861				}
1862			}
1863			return queue || [];
1864		}
1865	},
1866
1867	dequeue: function( elem, type ) {
1868		type = type || "fx";
1869
1870		var queue = jQuery.queue( elem, type ),
1871			startLength = queue.length,
1872			fn = queue.shift(),
1873			hooks = jQuery._queueHooks( elem, type ),
1874			next = function() {
1875				jQuery.dequeue( elem, type );
1876			};
1877
1878		// If the fx queue is dequeued, always remove the progress sentinel
1879		if ( fn === "inprogress" ) {
1880			fn = queue.shift();
1881			startLength--;
1882		}
1883
1884		if ( fn ) {
1885
1886			// Add a progress sentinel to prevent the fx queue from being
1887			// automatically dequeued
1888			if ( type === "fx" ) {
1889				queue.unshift( "inprogress" );
1890			}
1891
1892			// clear up the last queue stop function
1893			delete hooks.stop;
1894			fn.call( elem, next, hooks );
1895		}
1896
1897		if ( !startLength && hooks ) {
1898			hooks.empty.fire();
1899		}
1900	},
1901
1902	// not intended for public consumption - generates a queueHooks object, or returns the current one
1903	_queueHooks: function( elem, type ) {
1904		var key = type + "queueHooks";
1905		return jQuery._data( elem, key ) || jQuery._data( elem, key, {
1906			empty: jQuery.Callbacks("once memory").add(function() {
1907				jQuery.removeData( elem, type + "queue", true );
1908				jQuery.removeData( elem, key, true );
1909			})
1910		});
1911	}
1912});
1913
1914jQuery.fn.extend({
1915	queue: function( type, data ) {
1916		var setter = 2;
1917
1918		if ( typeof type !== "string" ) {
1919			data = type;
1920			type = "fx";
1921			setter--;
1922		}
1923
1924		if ( arguments.length < setter ) {
1925			return jQuery.queue( this[0], type );
1926		}
1927
1928		return data === undefined ?
1929			this :
1930			this.each(function() {
1931				var queue = jQuery.queue( this, type, data );
1932
1933				// ensure a hooks for this queue
1934				jQuery._queueHooks( this, type );
1935
1936				if ( type === "fx" && queue[0] !== "inprogress" ) {
1937					jQuery.dequeue( this, type );
1938				}
1939			});
1940	},
1941	dequeue: function( type ) {
1942		return this.each(function() {
1943			jQuery.dequeue( this, type );
1944		});
1945	},
1946	// Based off of the plugin by Clint Helfers, with permission.
1947	// http://blindsignals.com/index.php/2009/07/jquery-delay/
1948	delay: function( time, type ) {
1949		time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
1950		type = type || "fx";
1951
1952		return this.queue( type, function( next, hooks ) {
1953			var timeout = setTimeout( next, time );
1954			hooks.stop = function() {
1955				clearTimeout( timeout );
1956			};
1957		});
1958	},
1959	clearQueue: function( type ) {
1960		return this.queue( type || "fx", [] );
1961	},
1962	// Get a promise resolved when queues of a certain type
1963	// are emptied (fx is the type by default)
1964	promise: function( type, obj ) {
1965		var tmp,
1966			count = 1,
1967			defer = jQuery.Deferred(),
1968			elements = this,
1969			i = this.length,
1970			resolve = function() {
1971				if ( !( --count ) ) {
1972					defer.resolveWith( elements, [ elements ] );
1973				}
1974			};
1975
1976		if ( typeof type !== "string" ) {
1977			obj = type;
1978			type = undefined;
1979		}
1980		type = type || "fx";
1981
1982		while( i-- ) {
1983			tmp = jQuery._data( elements[ i ], type + "queueHooks" );
1984			if ( tmp && tmp.empty ) {
1985				count++;
1986				tmp.empty.add( resolve );
1987			}
1988		}
1989		resolve();
1990		return defer.promise( obj );
1991	}
1992});
1993var nodeHook, boolHook, fixSpecified,
1994	rclass = /[\t\r\n]/g,
1995	rreturn = /\r/g,
1996	rtype = /^(?:button|input)$/i,
1997	rfocusable = /^(?:button|input|object|select|textarea)$/i,
1998	rclickable = /^a(?:rea|)$/i,
1999	rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
2000	getSetAttribute = jQuery.support.getSetAttribute;
2001
2002jQuery.fn.extend({
2003	attr: function( name, value ) {
2004		return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
2005	},
2006
2007	removeAttr: function( name ) {
2008		return this.each(function() {
2009			jQuery.removeAttr( this, name );
2010		});
2011	},
2012
2013	prop: function( name, value ) {
2014		return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
2015	},
2016
2017	removeProp: function( name ) {
2018		name = jQuery.propFix[ name ] || name;
2019		return this.each(function() {
2020			// try/catch handles cases where IE balks (such as removing a property on window)
2021			try {
2022				this[ name ] = undefined;
2023				delete this[ name ];
2024			} catch( e ) {}
2025		});
2026	},
2027
2028	addClass: function( value ) {
2029		var classNames, i, l, elem,
2030			setClass, c, cl;
2031
2032		if ( jQuery.isFunction( value ) ) {
2033			return this.each(function( j ) {
2034				jQuery( this ).addClass( value.call(this, j, this.className) );
2035			});
2036		}
2037
2038		if ( value && typeof value === "string" ) {
2039			classNames = value.split( core_rspace );
2040
2041			for ( i = 0, l = this.length; i < l; i++ ) {
2042				elem = this[ i ];
2043
2044				if ( elem.nodeType === 1 ) {
2045					if ( !elem.className && classNames.length === 1 ) {
2046						elem.className = value;
2047
2048					} else {
2049						setClass = " " + elem.className + " ";
2050
2051						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2052							if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
2053								setClass += classNames[ c ] + " ";
2054							}
2055						}
2056						elem.className = jQuery.trim( setClass );
2057					}
2058				}
2059			}
2060		}
2061
2062		return this;
2063	},
2064
2065	removeClass: function( value ) {
2066		var removes, className, elem, c, cl, i, l;
2067
2068		if ( jQuery.isFunction( value ) ) {
2069			return this.each(function( j ) {
2070				jQuery( this ).removeClass( value.call(this, j, this.className) );
2071			});
2072		}
2073		if ( (value && typeof value === "string") || value === undefined ) {
2074			removes = ( value || "" ).split( core_rspace );
2075
2076			for ( i = 0, l = this.length; i < l; i++ ) {
2077				elem = this[ i ];
2078				if ( elem.nodeType === 1 && elem.className ) {
2079
2080					className = (" " + elem.className + " ").replace( rclass, " " );
2081
2082					// loop over each item in the removal list
2083					for ( c = 0, cl = removes.length; c < cl; c++ ) {
2084						// Remove until there is nothing to remove,
2085						while ( className.indexOf(" " + removes[ c ] + " ") > -1 ) {
2086							className = className.replace( " " + removes[ c ] + " " , " " );
2087						}
2088					}
2089					elem.className = value ? jQuery.trim( className ) : "";
2090				}
2091			}
2092		}
2093
2094		return this;
2095	},
2096
2097	toggleClass: function( value, stateVal ) {
2098		var type = typeof value,
2099			isBool = typeof stateVal === "boolean";
2100
2101		if ( jQuery.isFunction( value ) ) {
2102			return this.each(function( i ) {
2103				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
2104			});
2105		}
2106
2107		return this.each(function() {
2108			if ( type === "string" ) {
2109				// toggle individual class names
2110				var className,
2111					i = 0,
2112					self = jQuery( this ),
2113					state = stateVal,
2114					classNames = value.split( core_rspace );
2115
2116				while ( (className = classNames[ i++ ]) ) {
2117					// check each className given, space separated list
2118					state = isBool ? state : !self.hasClass( className );
2119					self[ state ? "addClass" : "removeClass" ]( className );
2120				}
2121
2122			} else if ( type === "undefined" || type === "boolean" ) {
2123				if ( this.className ) {
2124					// store className if set
2125					jQuery._data( this, "__className__", this.className );
2126				}
2127
2128				// toggle whole className
2129				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2130			}
2131		});
2132	},
2133
2134	hasClass: function( selector ) {
2135		var className = " " + selector + " ",
2136			i = 0,
2137			l = this.length;
2138		for ( ; i < l; i++ ) {
2139			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2140				return true;
2141			}
2142		}
2143
2144		return false;
2145	},
2146
2147	val: function( value ) {
2148		var hooks, ret, isFunction,
2149			elem = this[0];
2150
2151		if ( !arguments.length ) {
2152			if ( elem ) {
2153				hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
2154
2155				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2156					return ret;
2157				}
2158
2159				ret = elem.value;
2160
2161				return typeof ret === "string" ?
2162					// handle most common string cases
2163					ret.replace(rreturn, "") :
2164					// handle cases where value is null/undef or number
2165					ret == null ? "" : ret;
2166			}
2167
2168			return;
2169		}
2170
2171		isFunction = jQuery.isFunction( value );
2172
2173		return this.each(function( i ) {
2174			var val,
2175				self = jQuery(this);
2176
2177			if ( this.nodeType !== 1 ) {
2178				return;
2179			}
2180
2181			if ( isFunction ) {
2182				val = value.call( this, i, self.val() );
2183			} else {
2184				val = value;
2185			}
2186
2187			// Treat null/undefined as ""; convert numbers to string
2188			if ( val == null ) {
2189				val = "";
2190			} else if ( typeof val === "number" ) {
2191				val += "";
2192			} else if ( jQuery.isArray( val ) ) {
2193				val = jQuery.map(val, function ( value ) {
2194					return value == null ? "" : value + "";
2195				});
2196			}
2197
2198			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
2199
2200			// If set returns undefined, fall back to normal setting
2201			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
2202				this.value = val;
2203			}
2204		});
2205	}
2206});
2207
2208jQuery.extend({
2209	valHooks: {
2210		option: {
2211			get: function( elem ) {
2212				// attributes.value is undefined in Blackberry 4.7 but
2213				// uses .value. See #6932
2214				var val = elem.attributes.value;
2215				return !val || val.specified ? elem.value : elem.text;
2216			}
2217		},
2218		select: {
2219			get: function( elem ) {
2220				var value, i, max, option,
2221					index = elem.selectedIndex,
2222					values = [],
2223					options = elem.options,
2224					one = elem.type === "select-one";
2225
2226				// Nothing was selected
2227				if ( index < 0 ) {
2228					return null;
2229				}
2230
2231				// Loop through all the selected options
2232				i = one ? index : 0;
2233				max = one ? index + 1 : options.length;
2234				for ( ; i < max; i++ ) {
2235					option = options[ i ];
2236
2237					// Don't return options that are disabled or in a disabled optgroup
2238					if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2239							(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
2240
2241						// Get the specific value for the option
2242						value = jQuery( option ).val();
2243
2244						// We don't need an array for one selects
2245						if ( one ) {
2246							return value;
2247						}
2248
2249						// Multi-Selects return an array
2250						values.push( value );
2251					}
2252				}
2253
2254				// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2255				if ( one && !values.length && options.length ) {
2256					return jQuery( options[ index ] ).val();
2257				}
2258
2259				return values;
2260			},
2261
2262			set: function( elem, value ) {
2263				var values = jQuery.makeArray( value );
2264
2265				jQuery(elem).find("option").each(function() {
2266					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2267				});
2268
2269				if ( !values.length ) {
2270					elem.selectedIndex = -1;
2271				}
2272				return values;
2273			}
2274		}
2275	},
2276
2277	// Unused in 1.8, left in so attrFn-stabbers won't die; remove in 1.9
2278	attrFn: {},
2279
2280	attr: function( elem, name, value, pass ) {
2281		var ret, hooks, notxml,
2282			nType = elem.nodeType;
2283
2284		// don't get/set attributes on text, comment and attribute nodes
2285		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2286			return;
2287		}
2288
2289		if ( pass && jQuery.isFunction( jQuery.fn[ name ] ) ) {
2290			return jQuery( elem )[ name ]( value );
2291		}
2292
2293		// Fallback to prop when attributes are not supported
2294		if ( typeof elem.getAttribute === "undefined" ) {
2295			return jQuery.prop( elem, name, value );
2296		}
2297
2298		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2299
2300		// All attributes are lowercase
2301		// Grab necessary hook if one is defined
2302		if ( notxml ) {
2303			name = name.toLowerCase();
2304			hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
2305		}
2306
2307		if ( value !== undefined ) {
2308
2309			if ( value === null ) {
2310				jQuery.removeAttr( elem, name );
2311				return;
2312
2313			} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2314				return ret;
2315
2316			} else {
2317				elem.setAttribute( name, "" + value

2317 );
2318				return value;
2319			}
2320
2321		} else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
2322			return ret;
2323
2324		} else {
2325
2326			ret = elem.getAttribute( name );
2327
2328			// Non-existent attributes return null, we normalize to undefined
2329			return ret === null ?
2330				undefined :
2331				ret;
2332		}
2333	},
2334
2335	removeAttr: function( elem, value ) {
2336		var propName, attrNames, name, isBool,
2337			i = 0;
2338
2339		if ( value && elem.nodeType === 1 ) {
2340
2341			attrNames = value.split( core_rspace );
2342
2343			for ( ; i < attrNames.length; i++ ) {
2344				name = attrNames[ i ];
2345
2346				if ( name ) {
2347					propName = jQuery.propFix[ name ] || name;
2348					isBool = rboolean.test( name );
2349
2350					// See #9699 for explanation of this approach (setting first, then removal)
2351					// Do not do this for boolean attributes (see #10870)
2352					if ( !isBool ) {
2353						jQuery.attr( elem, name, "" );
2354					}
2355					elem.removeAttribute( getSetAttribute ? name : propName );
2356
2357					// Set corresponding property to false for boolean attributes
2358					if ( isBool && propName in elem ) {
2359						elem[ propName ] = false;
2360					}
2361				}
2362			}
2363		}
2364	},
2365
2366	attrHooks: {
2367		type: {
2368			set: function( elem, value ) {
2369				// We can't allow the type property to be changed (since it causes problems in IE)
2370				if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
2371					jQuery.error( "type property can't be changed" );
2372				} else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2373					// Setting the type on a radio button after the value resets the value in IE6-9
2374					// Reset value to it's default in case type is set after value
2375					// This is for element creation
2376					var val = elem.value;
2377					elem.setAttribute( "type", value );
2378					if ( val ) {
2379						elem.value = val;
2380					}
2381					return value;
2382				}
2383			}
2384		},
2385		// Use the value property for back compat
2386		// Use the nodeHook for button elements in IE6/7 (#1954)
2387		value: {
2388			get: function( elem, name ) {
2389				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2390					return nodeHook.get( elem, name );
2391				}
2392				return name in elem ?
2393					elem.value :
2394					null;
2395			},
2396			set: function( elem, value, name ) {
2397				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2398					return nodeHook.set( elem, value, name );
2399				}
2400				// Does not return so that setAttribute is also used
2401				elem.value = value;
2402			}
2403		}
2404	},
2405
2406	propFix: {
2407		tabindex: "tabIndex",
2408		readonly: "readOnly",
2409		"for": "htmlFor",
2410		"class": "className",
2411		maxlength: "maxLength",
2412		cellspacing: "cellSpacing",
2413		cellpadding: "cellPadding",
2414		rowspan: "rowSpan",
2415		colspan: "colSpan",
2416		usemap: "useMap",
2417		frameborder: "frameBorder",
2418		contenteditable: "contentEditable"
2419	},
2420
2421	prop: function( elem, name, value ) {
2422		var ret, hooks, notxml,
2423			nType = elem.nodeType;
2424
2425		// don't get/set properties on text, comment and attribute nodes
2426		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2427			return;
2428		}
2429
2430		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2431
2432		if ( notxml ) {
2433			// Fix name and attach hooks
2434			name = jQuery.propFix[ name ] || name;
2435			hooks = jQuery.propHooks[ name ];
2436		}
2437
2438		if ( value !== undefined ) {
2439			if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2440				return ret;
2441
2442			} else {
2443				return ( elem[ name ] = value );
2444			}
2445
2446		} else {
2447			if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
2448				return ret;
2449
2450			} else {
2451				return elem[ name ];
2452			}
2453		}
2454	},
2455
2456	propHooks: {
2457		tabIndex: {
2458			get: function( elem ) {
2459				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2460				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2461				var attributeNode = elem.getAttributeNode("tabindex");
2462
2463				return attributeNode && attributeNode.specified ?
2464					parseInt( attributeNode.value, 10 ) :
2465					rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
2466						0 :
2467						undefined;
2468			}
2469		}
2470	}
2471});
2472
2473// Hook for boolean attributes
2474boolHook = {
2475	get: function( elem, name ) {
2476		// Align boolean attributes with corresponding properties
2477		// Fall back to attribute presence where some booleans are not supported
2478		var attrNode,
2479			property = jQuery.prop( elem, name );
2480		return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
2481			name.toLowerCase() :
2482			undefined;
2483	},
2484	set: function( elem, value, name ) {
2485		var propName;
2486		if ( value === false ) {
2487			// Remove boolean attributes when set to false
2488			jQuery.removeAttr( elem, name );
2489		} else {
2490			// value is true since we know at this point it's type boolean and not false
2491			// Set boolean attributes to the same name and set the DOM property
2492			propName = jQuery.propFix[ name ] || name;
2493			if ( propName in elem ) {
2494				// Only set the IDL specifically if it already exists on the element
2495				elem[ propName ] = true;
2496			}
2497
2498			elem.setAttribute( name, name.toLowerCase() );
2499		}
2500		return name;
2501	}
2502};
2503
2504// IE6/7 do not support getting/setting some attributes with get/setAttribute
2505if ( !getSetAttribute ) {
2506
2507	fixSpecified = {
2508		name: true,
2509		id: true,
2510		coords: true
2511	};
2512
2513	// Use this for any attribute in IE6/7
2514	// This fixes almost every IE6/7 issue
2515	nodeHook = jQuery.valHooks.button = {
2516		get: function( elem, name ) {
2517			var ret;
2518			ret = elem.getAttributeNode( name );
2519			return ret && ( fixSpecified[ name ] ? ret.value !== "" : ret.specified ) ?
2520				ret.value :
2521				undefined;
2522		},
2523		set: function( elem, value, name ) {
2524			// Set the existing or create a new attribute node
2525			var ret = elem.getAttributeNode( name );
2526			if ( !ret ) {
2527				ret = document.createAttribute( name );
2528				elem.setAttributeNode( ret );
2529			}
2530			return ( ret.value = value + "" );
2531		}
2532	};
2533
2534	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
2535	// This is for removals
2536	jQuery.each([ "width", "height" ], function( i, name ) {
2537		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2538			set: function( elem, value ) {
2539				if ( value === "" ) {
2540					elem.setAttribute( name, "auto" );
2541					return value;
2542				}
2543			}
2544		});
2545	});
2546
2547	// Set contenteditable to false on removals(#10429)
2548	// Setting to empty string throws an error as an invalid value
2549	jQuery.attrHooks.contenteditable = {
2550		get: nodeHook.get,
2551		set: function( elem, value, name ) {
2552			if ( value === "" ) {
2553				value = "false";
2554			}
2555			nodeHook.set( elem, value, name );
2556		}
2557	};
2558}
2559
2560
2561// Some attributes require a special call on IE
2562if ( !jQuery.support.hrefNormalized ) {
2563	jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
2564		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2565			get: function( elem ) {
2566				var ret = elem.getAttribute( name, 2 );
2567				return ret === null ? undefined : ret;
2568			}
2569		});
2570	});
2571}
2572
2573if ( !jQuery.support.style ) {
2574	jQuery.attrHooks.style = {
2575		get: function( elem ) {
2576			// Return undefined in the case of empty string
2577			// Normalize to lowercase since IE uppercases css property names
2578			return elem.style.cssText.toLowerCase() || undefined;
2579		},
2580		set: function( elem, value ) {
2581			return ( elem.style.cssText = 

2581"" + value );
2582		}
2583	};
2584}
2585
2586// Safari mis-reports the default selected property of an option
2587// Accessing the parent's selectedIndex property fixes it
2588if ( !jQuery.support.optSelected ) {
2589	jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
2590		get: function( elem ) {
2591			var parent = elem.parentNode;
2592
2593			if ( parent ) {
2594				parent.selectedIndex;
2595
2596				// Make sure that it also works with optgroups, see #5701
2597				if ( parent.parentNode ) {
2598					parent.parentNode.selectedIndex;
2599				}
2600			}
2601			return null;
2602		}
2603	});
2604}
2605
2606// IE6/7 call enctype encoding
2607if ( !jQuery.support.enctype ) {
2608	jQuery.propFix.enctype = "encoding";
2609}
2610
2611// Radios and checkboxes getter/setter
2612if ( !jQuery.support.checkOn ) {
2613	jQuery.each([ "radio", "checkbox" ], function() {
2614		jQuery.valHooks[ this ] = {
2615			get: function( elem ) {
2616				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2617				return elem.getAttribute("value") === null ? "on" : elem.value;
2618			}
2619		};
2620	});
2621}
2622jQuery.each([ "radio", "checkbox" ], function() {
2623	jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2624		set: function( elem, value ) {
2625			if ( jQuery.isArray( value ) ) {
2626				return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
2627			}
2628		}
2629	});
2630});
2631var rformElems = /^(?:textarea|input|select)$/i,
2632	rtypenamespace = /^([^\.]*|)(?:\.(.+)|)$/,
2633	rhoverHack = /(?:^|\s)hover(\.\S+|)\b/,
2634	rkeyEvent = /^key/,
2635	rmouseEvent = /^(?:mouse|contextmenu)|click/,
2636	rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
2637	hoverHack = function( events ) {
2638		return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
2639	};
2640
2641/*
2642 * Helper functions for managing events -- not part of the public interface.
2643 * Props to Dean Edwards' addEvent library for many of the ideas.
2644 */
2645jQuery.event = {
2646
2647	add: function( elem, types, handler, data, selector ) {
2648
2649		var elemData, eventHandle, events,
2650			t, tns, type, namespaces, handleObj,
2651			handleObjIn, handlers, special;
2652
2653		// Don't attach events to noData or text/comment nodes (allow plain objects tho)
2654		if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
2655			return;
2656		}
2657
2658		// Caller can pass in an object of custom data in lieu of the handler
2659		if ( handler.handler ) {
2660			handleObjIn = handler;
2661			handler = handleObjIn.handler;
2662			selector = handleObjIn.selector;
2663		}
2664
2665		// Make sure that the handler has a unique ID, used to find/remove it later
2666		if ( !handler.guid ) {
2667			handler.guid = jQuery.guid++;
2668		}
2669
2670		// Init the element's event structure and main handler, if this is the first
2671		events = elemData.events;
2672		if ( !events ) {
2673			elemData.events = events = {};
2674		}
2675		eventHandle = elemData.handle;
2676		if ( !eventHandle ) {
2677			elemData.handle = eventHandle = function( e ) {
2678				// Discard the second event of a jQuery.event.trigger() and
2679				// when an event is called after a page has unloaded
2680				return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
2681					jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
2682					undefined;
2683			};
2684			// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
2685			eventHandle.elem = elem;
2686		}
2687
2688		// Handle multiple events separated by a space
2689		// jQuery(...).bind("mouseover mouseout", fn);
2690		types = jQuery.trim( hoverHack(types) ).split( " " );
2691		for ( t = 0; t < types.length; t++ ) {
2692
2693			tns = rtypenamespace.exec( types[t] ) || [];
2694			type = tns[1];
2695			namespaces = ( tns[2] || "" ).split( "." ).sort();
2696
2697			// If event changes its type, use the special event handlers for the changed type
2698			special = jQuery.event.special[ type ] || {};
2699
2700			// If selector defined, determine special event api type, otherwise given type
2701			type = ( selector ? special.delegateType : special.bindType ) || type;
2702
2703			// Update special based on newly reset type
2704			special = jQuery.event.special[ type ] || {};
2705
2706			// handleObj is passed to all event handlers
2707			handleObj = jQuery.extend({
2708				type: type,
2709				origType: tns[1],
2710				data: data,
2711				handler: handler,
2712				guid: handler.guid,
2713				selector: selector,
2714				namespace: namespaces.join(".")
2715			}, handleObjIn );
2716
2717			// Init the event handler queue if we're the first
2718			handlers = events[ type ];
2719			if ( !handlers ) {
2720				handlers = events[ type ] = [];
2721				handlers.delegateCount = 0;
2722
2723				// Only use addEventListener/attachEvent if the special events handler returns false
2724				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2725					// Bind the global event handler to the element
2726					if ( elem.addEventListener ) {
2727						elem.addEventListener( type, eventHandle, false );
2728
2729					} else if ( elem.attachEvent ) {
2730						elem.attachEvent( "on" + type, eventHandle );
2731					}
2732				}
2733			}
2734
2735			if ( special.add ) {
2736				special.add.call( elem, handleObj );
2737
2738				if ( !handleObj.handler.guid ) {
2739					handleObj.handler.guid = handler.guid;
2740				}
2741			}
2742
2743			// Add to the element's handler list, delegates in front
2744			if ( selector ) {
2745				handlers.splice( handlers.delegateCount++, 0, handleObj );
2746			} else {
2747				handlers.push( handleObj );
2748			}
2749
2750			// Keep track of which events have ever been used, for event optimization
2751			jQuery.event.global[ type ] = true;
2752		}
2753
2754		// Nullify elem to prevent memory leaks in IE
2755		elem = null;
2756	},
2757
2758	global: {},
2759
2760	// Detach an event or set of events from an element
2761	remove: function( elem, types, handler, selector, mappedTypes ) {
2762
2763		var t, tns, type, origType, namespaces, origCount,
2764			j, events, special, eventType, handleObj,
2765			elemData = jQuery.hasData( elem ) && jQuery._data( elem );
2766
2767		if ( !elemData || !(events = elemData.events) ) {
2768			return;
2769		}
2770
2771		// Once for each type.namespace in types; type may be omitted
2772		types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
2773		for ( t = 0; t < types.length; t++ ) {
2774			tns = rtypenamespace.exec( types[t] ) || [];
2775			type = origType = tns[1];
2776			namespaces = tns[2];
2777
2778			// Unbind all events (on this namespace, if provided) for the element
2779			if ( !type ) {
2780				for ( type in events ) {
2781					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
2782				}
2783				continue;
2784			}
2785
2786			special = jQuery.event.special[ type ] || {};
2787			type = ( selector? special.delegateType : special.bindType ) || type;
2788			eventType = events[ type ] || [];
2789			origCount = eventType.length;
2790			namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
2791
2792			// Remove matching events
2793			for ( j = 0; j < eventType.length; j++ ) {
2794				handleObj = eventType[ j ];
2795
2796				if ( ( mappedTypes || origType === handleObj.origType ) &&
2797					 ( !handler || handler.guid === handleObj.guid ) &&
2798					 ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
2799					 ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
2800					eventType.splice( j--, 1 );
2801
2802					if ( handleObj.selector ) {
2803						eventType.delegateCount--;
2804					}
2805					if ( special.remove ) {
2806						special.remove.call( elem, handleObj );
2807					}
2808				}
2809			}
2810
2811			// Remove generic event handler if we removed something and no more handlers exist
2812			// (avoids potential for endless recursion during removal of special event handlers)
2813			if ( eventType.length === 0 && origCount !== eventType.length ) {
2814				if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
2815					jQuery.removeEvent( elem, type, elemData.handle );
2816				}
2817
2818				delete events[ type ];
2819			}
2820		}
2821
2822		// Remove the expando if it's no longer used
2823		if ( jQuery.isEmptyObject( events ) ) {
2824			delete elemData.handle;
2825
2826			// removeData also checks for emptiness and clears the expando if empty
2827			// so use it instead of delete
2828			jQuery.removeData( elem, "events", true );
2829		}
2830	},
2831
2832	// Events that are safe to short-circuit if no handlers are attached.
2833	// Native DOM events should not be added, they may have inline handlers.
2834	customEvent: {
2835		"getData": true,
2836		"setData": true,
2837		"changeData": true
2838	},
2839
2840	trigger: function( event, data, elem, onlyHandlers ) {
2841		// Don't do events on text and comment nodes
2842		if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
2843			return;
2844		}
2845
2846		// Event object or event type
2847		var cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType,
2848			type = event.type || event,
2849			namespaces = [];
2850
2851		// focus/blur morphs to focusin/out; ensure we're not firing them right now
2852		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
2853			return;
2854		}
2855
2856		if ( type.indexOf( "!" ) >= 0 ) {
2857			// Exclusive events trigger only for the exact event (no namespaces)
2858			type = type.slice(0, -1);
2859			exclusive = true;
2860		}
2861
2862		if ( type.indexOf( "." ) >= 0 ) {
2863			// Namespaced trigger; create a regexp to match event type in handle()
2864			namespaces = type.split(".");
2865			type = namespaces.shift();
2866			namespaces.sort();
2867		}
2868
2869		if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
2870			// No jQuery handlers for this event type, and it can't have inline handlers
2871			return;
2872		}
2873
2874		// Caller can pass in an Event, Object, or just an event type string
2875		event = typeof event === "object" ?
2876			// jQuery.Event object
2877			event[ jQuery.expando ] ? event :
2878			// Object literal
2879			new jQuery.Event( type, event ) :
2880			// Just the event type (string)
2881			new jQuery.Event( type );
2882
2883		event.type = type;
2884		event.isTrigger = true;
2885		event.exclusive = exclusive;
2886		event.namespace = namespaces.join( "." );
2887		event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
2888		ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
2889
2890		// Handle a global trigger
2891		if ( !elem ) {
2892
2893			// TODO: Stop taunting the data cache; remove global events and always attach to document
2894			cache = jQuery.cache;
2895			for ( i in cache ) {
2896				if ( cache[ i ].events && cache[ i ].events[ type ] ) {
2897					jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
2898				}
2899			}
2900			return;
2901		}
2902
2903		// Clean up the event in case it is being reused
2904		event.result = undefined;
2905		if ( !event.target ) {
2906			event.target = elem;
2907		}
2908
2909		// Clone any incoming data and prepend the event, creating the handler arg list
2910		data = data != null ? jQuery.makeArray( data ) : [];
2911		data.unshift( event );
2912
2913		// Allow special events to draw outside the lines
2914		special = jQuery.event.special[ type ] || {};
2915		if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
2916			return;
2917		}
2918
2919		// Determine event propagation path in advance, per W3C events spec (#9951)
2920		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
2921		eventPath = [[ elem, special.bindType || type ]];
2922		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
2923
2924			bubbleType = special.delegateType || type;
2925			cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
2926			for ( old = elem; cur; cur = cur.parentNode ) {
2927				eventPath.push([ cur, bubbleType ]);
2928				old = cur;
2929			}
2930
2931			// Only add window if we got to document (e.g., not plain obj or detached DOM)
2932			if ( old === (elem.ownerDocument || document) ) {
2933				eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
2934			}
2935		}
2936
2937		// Fire handlers on the event path
2938		for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
2939
2940			cur = eventPath[i][0];
2941			event.type = eventPath[i][1];
2942
2943			handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
2944			if ( handle ) {
2945				handle.apply( cur, data );
2946			}
2947			// Note that this is a bare JS function and not a jQuery handler
2948			handle = ontype && cur[ ontype ];
2949			if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) {
2950				event.preventDefault();
2951			}
2952		}
2953		event.type = type;
2954
2955		// If nobody prevented the default action, do it now
2956		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
2957
2958			if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
2959				!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
2960
2961				// Call a native DOM method on the target with the same name name as the event.
2962				// Can't use an .isFunction() check here because IE6/7 fails that test.
2963				// Don't do default actions on window, that's where global variables be (#6170)
2964				// IE<9 dies on focus/blur to hidden element (#1486)
2965				if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
2966
2967					// Don't re-trigger an onFOO event when we call its FOO() method
2968					old = elem[ ontype ];
2969
2970					if ( old ) {
2971						elem[ ontype ] = null;
2972					}
2973
2974					// Prevent re-triggering of the same event, since we already bubbled it above
2975					jQuery.event.triggered = type;
2976					elem[ type ]();
2977					jQuery.event.triggered = undefined;
2978
2979					if ( old ) {
2980						elem[ ontype ] = old;
2981					}
2982				}
2983			}
2984		}
2985
2986		return event.result;
2987	},
2988
2989	dispatch: function( event ) {
2990
2991		// Make a writable jQuery.Event from the native event object
2992		event = jQuery.event.fix( event || window.event );
2993
2994		var i, j, cur, ret, selMatch, matched, matches, handleObj, sel, related,
2995			handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
2996			delegateCount = handlers.delegateCount,
2997			args = [].slice.call( arguments ),
2998			run_all = !event.exclusive && !event.namespace,
2999			special = jQuery.event.special[ event.type ] || {},
3000			handlerQueue = [];
3001
3002		// Use the fix-ed jQuery.Event rather than the (read-only) native event
3003		args[0] = event;
3004		event.delegateTarget = this;
3005
3006		// Call the preDispatch hook for the mapped type, and let it bail if desired
3007		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
3008			return;
3009		}
3010
3011		// Determine handlers that should run if there are delegated events
3012		// Avoid non-left-click bubbling in Firefox (#3861)
3013		if ( delegateCount && !(event.button && event.type === "click") ) {
3014
3015			for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
3016
3017				// Don't process clicks (ONLY) on disabled elements (#6911, #8165, #11382, #11764)
3018				if ( cur.disabled !== true || event.type !== "click" ) {
3019					selMatch = {};
3020					matches = [];
3021					for ( i = 0; i < delegateCount; i++ ) {
3022						handleObj = handlers[ i ];
3023						sel = handleObj.selector;
3024
3025						if ( selMatch[ sel ] === undefined ) {
3026							selMatch[ sel ] = jQuery( sel, this ).index( cur ) >= 0;
3027						}
3028						if ( selMatch[ sel ] ) {
3029							matches.push( handleObj );
3030						}
3031					}
3032					if ( matches.length ) {
3033						handlerQueue.push({ elem: cur, matches: matches });
3034					}
3035				}
3036			}
3037		}
3038
3039		// Add the remaining (directly-bound) handlers
3040		if ( handlers.length > delegateCount ) {
3041			handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
3042		}
3043
3044		// Run delegates first; they may want to stop propagation beneath us
3045		for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
3046			matched = handlerQueue[ i ];
3047			event.currentTarget = matched.elem;
3048
3049			for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
3050				handleObj = matched.matches[ j ];
3051
3052				// Triggered event must either 1) be non-exclusive and have no namespace, or
3053				// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
3054				if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
3055
3056					event.data = handleObj.data;
3057					event.handleObj = handleObj;
3058
3059					ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
3060							.apply( matched.elem, args );
3061
3062					if ( ret !== undefined ) {
3063						event.result = ret;
3064						if ( ret === false ) {
3065							event.preventDefault();
3066							event.stopPropagation();
3067						}
3068					}
3069				}
3070			}
3071		}
3072
3073		// Call the postDispatch hook for the mapped type
3074		if ( special.postDispatch ) {
3075			special.postDispatch.call( this, event );
3076		}
3077
3078		return event.result;
3079	},
3080
3081	// Includes some event props shared by KeyEvent and MouseEvent
3082	// *** attrChange attrName relatedNode srcElement  are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
3083	props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
3084
3085	fixHooks: {},
3086
3087	keyHooks: {
3088		props: "char charCode key keyCode".split(" "),
3089		filter: function( event, original ) {
3090
3091			// Add which for key events
3092			if ( event.which == null ) {
3093				event.which = original.charCode != null ? original.charCode : original.keyCode;
3094			}
3095
3096			return event;
3097		}
3098	},
3099
3100	mouseHooks: {
3101		props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
3102		filter: function( event, original ) {
3103			var eventDoc, doc, body,
3104				button = original.button,
3105				fromElement = original.fromElement;
3106
3107			// Calculate pageX/Y if missing and clientX/Y available
3108			if ( event.pageX == null && original.clientX != null ) {
3109				eventDoc = event.target.ownerDocument || document;
3110				doc = eventDoc.documentElement;
3111				body = eventDoc.body;
3112
3113				event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
3114				event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
3115			}
3116
3117			// Add relatedTarget, if necessary
3118			if ( !event.relatedTarget && fromElement ) {
3119				event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
3120			}
3121
3122			// Add which for click: 1 === left; 2 === middle; 3 === right
3123			// Note: button is not normalized, so don't use it
3124			if ( !event.which && button !== undefined ) {
3125				event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
3126			}
3127
3128			return event;
3129		}
3130	},
3131
3132	fix: function( event ) {
3133		if ( event[ jQuery.expando ] ) {
3134			return event;
3135		}
3136
3137		// Create a writable copy of the event object and normalize some properties
3138		var i, prop,
3139			originalEvent = event,
3140			fixHook = jQuery.event.fixHooks[ event.type ] || {},
3141			copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
3142
3143		event = jQuery.Event( originalEvent );
3144
3145		for ( i = copy.length; i; ) {
3146			prop = copy[ --i ];
3147			event[ prop ] = originalEvent[ prop ];
3148		}
3149
3150		// Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
3151		if ( !event.target ) {
3152			event.target = originalEvent.srcElement || document;
3153		}
3154
3155		// Target should not be a text node (#504, Safari)
3156		if ( event.target.nodeType === 3 ) {
3157			event.target = event.target.parentNode;
3158		}
3159
3160		// For mouse/key events, metaKey==false if it's undefined (#3368, #11328; IE6/7/8)
3161		event.metaKey = !!event.metaKey;
3162
3163		return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
3164	},
3165
3166	special: {
3167		load: {
3168			// Prevent triggered image.load events from bubbling to window.load
3169			noBubble: true
3170		},
3171
3172		focus: {
3173			delegateType: "focusin"
3174		},
3175		blur: {
3176			delegateType: "focusout"
3177		},
3178
3179		beforeunload: {
3180			setup: function( data, namespaces, eventHandle ) {
3181				// We only want to do this special case on windows
3182				if ( jQuery.isWindow( this ) ) {
3183					this.onbeforeunload = eventHandle;
3184				}
3185			},
3186
3187			teardown: function( namespaces, eventHandle ) {
3188				if ( this.onbeforeunload === eventHandle ) {
3189					this.onbeforeunload = null;
3190				}
3191			}
3192		}
3193	},
3194
3195	simulate: function( type, elem, event, bubble ) {
3196		// Piggyback on a donor event to simulate a different one.
3197		// Fake originalEvent to avoid donor's stopPropagation, but if the
3198		// simulated event prevents default then we do the same on the donor.
3199		var e = jQuery.extend(
3200			new jQuery.Event(),
3201			event,
3202			{ type: type,
3203				isSimulated: true,
3204				originalEvent: {}
3205			}
3206		);
3207		if ( bubble ) {
3208			jQuery.event.trigger( e, null, elem );
3209		} else {
3210			jQuery.event.dispatch.call( elem, e );
3211		}
3212		if ( e.isDefaultPrevented() ) {
3213			event.preventDefault();
3214		}
3215	}
3216};
3217
3218// Some plugins are using, but it's undocumented/deprecated and will be removed.
3219// The 1.7 special event interface should provide all the hooks needed now.
3220jQuery.event.handle = jQuery.event.dispatch;
3221
3222jQuery.removeEvent = document.removeEventListener ?
3223	function( elem, type, handle ) {
3224		if ( elem.removeEventListener ) {
3225			elem.removeEventListener( type, handle, false );
3226		}
3227	} :
3228	function( elem, type, handle ) {
3229		var name = "on" + type;
3230
3231		if ( elem.detachEvent ) {
3232
3233			// #8545, #7054, preventing memory leaks for custom events in IE6-8 –
3234			// detachEvent needed property on element, by name of that event, to properly expose it to GC
3235			if ( typeof elem[ name ] === "undefined" ) {
3236				elem[ name ] = null;
3237			}
3238
3239			elem.detachEvent( name, handle );
3240		}
3241	};
3242
3243jQuery.Event = function( src, props ) {
3244	// Allow instantiation without the 'new' keyword
3245	if ( !(this instanceof jQuery.Event) ) {
3246		return new jQuery.Event( src, props );
3247	}
3248
3249	// Event object
3250	if ( src && src.type ) {
3251		this.originalEvent = src;
3252		this.type = src.type;
3253
3254		// Events bubbling up the document may have been marked as prevented
3255		// by a handler lower down the tree; reflect the correct value.
3256		this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
3257			src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
3258
3259	// Event type
3260	} else {
3261		this.type = src;
3262	}
3263
3264	// Put explicitly provided properties onto the event object
3265	if ( props ) {
3266		jQuery.extend( this, props );
3267	}
3268
3269	// Create a timestamp if incoming event doesn't have one
3270	this.timeStamp = src && src.timeStamp || jQuery.now();
3271
3272	// Mark it as fixed
3273	this[ jQuery.expando ] = true;
3274};
3275
3276function returnFalse() {
3277	return false;
3278}
3279function returnTrue() {
3280	return true;
3281}
3282
3283// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
3284// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
3285jQuery.Event.prototype = {
3286	preventDefault: function() {
3287		this.isDefaultPrevented = returnTrue;
3288
3289		var e = this.originalEvent;
3290		if ( !e ) {
3291			return;
3292		}
3293
3294		// if preventDefault exists run it on the original event
3295		if ( e.preventDefault ) {
3296			e.preventDefault();
3297
3298		// otherwise set the returnValue property of the original event to false (IE)
3299		} else {
3300			e.returnValue = false;
3301		}
3302	},
3303	stopPropagation: function() {
3304		this.isPropagationStopped = returnTrue;
3305
3306		var e = this.originalEvent;
3307		if ( !e ) {
3308			return;
3309		}
3310		// if stopPropagation exists run it on the original event
3311		if ( e.stopPropagation ) {
3312			e.stopPropagation();
3313		}
3314		// otherwise set the cancelBubble property of the original event to true (IE)
3315		e.cancelBubble = true;
3316	},
3317	stopImmediatePropagation: function() {
3318		this.isImmediatePropagationStopped = returnTrue;
3319		this.stopPropagation();
3320	},
3321	isDefaultPrevented: returnFalse,
3322	isPropagationStopped: returnFalse,
3323	isImmediatePropagationStopped: returnFalse
3324};
3325
3326// Create mouseenter/leave events using mouseover/out and event-time checks
3327jQuery.each({
3328	mouseenter: "mouseover",
3329	mouseleave: "mouseout"
3330}, function( orig, fix ) {
3331	jQuery.event.special[ orig ] = {
3332		delegateType: fix,
3333		bindType: fix,
3334
3335		handle: function( event ) {
3336			var ret,
3337				target = this,
3338				related = event.relatedTarget,
3339				handleObj = event.handleObj,
3340				selector = handleObj.selector;
3341
3342			// For mousenter/leave call the handler if related is outside the target.
3343			// NB: No relatedTarget if the mouse left/entered the browser window
3344			if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
3345				event.type = handleObj.origType;
3346				ret = handleObj.handler.apply( this, arguments );
3347				event.type = fix;
3348			}
3349			return ret;
3350		}
3351	};
3352});
3353
3354// IE submit delegation
3355if ( !jQuery.support.submitBubbles ) {
3356
3357	jQuery.event.special.submit = {
3358		setup: function() {
3359			// Only need this for delegated form submit events
3360			if ( jQuery.nodeName( this, "form" ) ) {
3361				return false;
3362			}
3363
3364			// Lazy-add a submit handler when a descendant form may potentially be submitted
3365			jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
3366				// Node name check avoids a VML-related crash in IE (#9807)
3367				var elem = e.target,
3368					form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
3369				if ( form && !jQuery._data( form, "_submit_attached" ) ) {
3370					jQuery.event.add( form, "submit._submit", function( event ) {
3371						event._submit_bubble = true;
3372					});
3373					jQuery._data( form, "_submit_attached", true );
3374				}
3375			});
3376			// return undefined since we don't need an event listener
3377		},
3378
3379		postDispatch: function( event ) {
3380			// If form was submitted by the user, bubble the event up the tree
3381			if ( event._submit_bubble ) {
3382				delete event._submit_bubble;
3383				if ( this.parentNode && !event.isTrigger ) {
3384					jQuery.event.simulate( "submit", this.parentNode, event, true );
3385				}
3386			}
3387		},
3388
3389		teardown: function() {
3390			// Only need this for delegated form submit events
3391			if ( jQuery.nodeName( this, "form" ) ) {
3392				return false;
3393			}
3394
3395			// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
3396			jQuery.event.remove( this, "._submit" );
3397		}
3398	};
3399}
3400
3401// IE change delegation and checkbox/radio fix
3402if ( !jQuery.support.changeBubbles ) {
3403
3404	jQuery.event.special.change = {
3405
3406		setup: function() {
3407
3408			if ( rformElems.test( this.nodeName ) ) {
3409				// IE doesn't fire change on a check/radio until blur; trigger it on click
3410				// after a propertychange. Eat the blur-change in special.change.handle.
3411				// This still fires onchange a second time for check/radio after blur.
3412				if ( this.type === "checkbox" || this.type === "radio" ) {
3413					jQuery.event.add( this, "propertychange._change", function( event ) {
3414						if ( event.originalEvent.propertyName === "checked" ) {
3415							this._just_changed = true;
3416						}
3417					});
3418					jQuery.event.add( this, "click._change", function( event ) {
3419						if ( this._just_changed && !event.isTrigger ) {
3420							this._just_changed = false;
3421						}
3422						// Allow triggered, simulated change events (#11500)
3423						jQuery.event.simulate( "change", this, event, true );
3424					});
3425				}
3426				return false;
3427			}
3428			// Delegated event; lazy-add a change handler on descendant inputs
3429			jQuery.event.add( this, "beforeactivate._change", function( e ) {
3430				var elem = e.target;
3431
3432				if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "_change_attached" ) ) {
3433					jQuery.event.add( elem, "change._change", function( event ) {
3434						if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
3435							jQuery.event.simulate( "change", this.parentNode, event, true );
3436						}
3437					});
3438					jQuery._data( elem, "_change_attached", true );
3439				}
3440			});
3441		},
3442
3443		handle: function( event ) {
3444			var elem = event.target;
3445
3446			// Swallow native change events from checkbox/radio, we already triggered them above
3447			if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
3448				return event.handleObj.handler.apply( this, arguments );
3449			}
3450		},
3451
3452		teardown: function() {
3453			jQuery.event.remove( this, "._change" );
3454
3455			return !rformElems.test( this.nodeName );
3456		}
3457	};
3458}
3459
3460// Create "bubbling" focus and blur events
3461if ( !jQuery.support.focusinBubbles ) {
3462	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
3463
3464		// Attach a single capturing handler while someone wants focusin/focusout
3465		var attaches = 0,
3466			handler = function( event ) {
3467				jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
3468			};
3469
3470		jQuery.event.special[ fix ] = {
3471			setup: function() {
3472				if ( attaches++ === 0 ) {
3473					document.addEventListener( orig, handler, true );
3474				}
3475			},
3476			teardown: function() {
3477				if ( --attaches === 0 ) {
3478					document.removeEventListener( orig, handler, true );
3479				}
3480			}
3481		};
3482	});
3483}
3484
3485jQuery.fn.extend({
3486
3487	on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
3488		var origFn, type;
3489
3490		// Types can be a map of types/handlers
3491		if ( typeof types === "object" ) {
3492			// ( types-Object, selector, data )
3493			if ( typeof selector !== "string" ) { // && selector != null
3494				// ( types-Object, data )
3495				data = data || selector;
3496				selector = undefined;
3497			}
3498			for ( type in types ) {
3499				this.on( type, selector, data, types[ type ], one );
3500			}
3501			return this;
3502		}
3503
3504		if ( data == null && fn == null ) {
3505			// ( types, fn )
3506			fn = selector;
3507			data = selector = undefined;
3508		} else if ( fn == null ) {
3509			if ( typeof selector === "string" ) {
3510				// ( types, selector, fn )
3511				fn = data;
3512				data = undefined;
3513			} else {
3514				// ( types, data, fn )
3515				fn = data;
3516				data = selector;
3517				selector = undefined;
3518			}
3519		}
3520		if ( fn === false ) {
3521			fn = returnFalse;
3522		} else if ( !fn ) {
3523			return this;
3524		}
3525
3526		if ( one === 1 ) {
3527			origFn = fn;
3528			fn = function( event ) {
3529				// Can use an empty set, since event contains the info
3530				jQuery().off( event );
3531				return origFn.apply( this, arguments );
3532			};
3533			// Use same guid so caller can remove using origFn
3534			fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
3535		}
3536		return this.each( function() {
3537			jQuery.event.add( this, types, fn, data, selector );
3538		});
3539	},
3540	one: function( types, selector, data, fn ) {
3541		return this.on( types, selector, data, fn, 1 );
3542	},
3543	off: function( types, selector, fn ) {
3544		var handleObj, type;
3545		if ( types && types.preventDefault && types.handleObj ) {
3546			// ( event )  dispatched jQuery.Event
3547			handleObj = types.handleObj;
3548			jQuery( types.delegateTarget ).off(
3549				handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
3550				handleObj.selector,
3551				handleObj.handler
3552			);
3553			return this;
3554		}
3555		if ( typeof types === "object" ) {
3556			// ( types-object [, selector] )
3557			for ( type in types ) {
3558				this.off( type, selector, types[ type ] );
3559			}
3560			return this;
3561		}
3562		if ( selector === false || typeof selector === "function" ) {
3563			// ( types [, fn] )
3564			fn = selector;
3565			selector = undefined;
3566		}
3567		if ( fn === false ) {
3568			fn = returnFalse;
3569		}
3570		return this.each(function() {
3571			jQuery.event.remove( this, types, fn, selector );
3572		});
3573	},
3574
3575	bind: function( types, data, fn ) {
3576		return this.on( types, null, data, fn );
3577	},
3578	unbind: function( types, fn ) {
3579		return this.off( types, null, fn );
3580	},
3581
3582	live: function( types, data, fn ) {
3583		jQuery( this.context ).on( types, this.selector, data, fn );
3584		return this;
3585	},
3586	die: function( types, fn ) {
3587		jQuery( this.context ).off( types, this.selector || "**", fn );
3588		return this;
3589	},
3590
3591	delegate: function( selector, types, data, fn ) {
3592		return this.on( types, selector, data, fn );
3593	},
3594	undelegate: function( selector, types, fn ) {
3595		// ( namespace ) or ( selector, types [, fn] )
3596		return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector || "**", fn );
3597	},
3598
3599	trigger: function( type, data ) {
3600		return this.each(function() {
3601			jQuery.event.trigger( type, data, this );
3602		});
3603	},
3604	triggerHandler: function( type, data ) {
3605		if ( this[0] ) {
3606			return jQuery.event.trigger( type, data, this[0], true );
3607		}
3608	},
3609
3610	toggle: function( fn ) {
3611		// Save reference to arguments for access in closure
3612		var args = arguments,
3613			guid = fn.guid || jQuery.guid++,
3614			i = 0,
3615			toggler = function( event ) {
3616				// Figure out which function to execute
3617				var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
3618				jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
3619
3620				// Make sure that clicks stop
3621				event.preventDefault();
3622
3623				// and execute the function
3624				return args[ lastToggle ].apply( this, arguments ) || false;
3625			};
3626
3627		// link all the functions, so any of them can unbind this click handler
3628		toggler.guid = guid;
3629		while ( i < args.length ) {
3630			args[ i++ ].guid = guid;
3631		}
3632
3633		return this.click( toggler );
3634	},
3635
3636	hover: function( fnOver, fnOut ) {
3637		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
3638	}
3639});
3640
3641jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
3642	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
3643	"change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
3644
3645	// Handle event binding
3646	jQuery.fn[ name ] = function( data, fn ) {
3647		if ( fn == null ) {
3648			fn = data;
3649			data = null;
3650		}
3651
3652		return arguments.length > 0 ?
3653			this.on( name, null, data, fn ) :
3654			this.trigger( name );
3655	};
3656
3657	if ( rkeyEvent.test( name ) ) {
3658		jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
3659	}
3660
3661	if ( rmouseEvent.test( name ) ) {
3662		jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
3663	}
3664});
3665/*!
3666 * Sizzle CSS Selector Engine
3667 *  Copyright 2012 jQuery Foundation and other contributors
3668 *  Released under the MIT license
3669 *  http://sizzlejs.com/
3670 */
3671(function( window, undefined ) {
3672
3673var dirruns,
3674	cachedruns,
3675	assertGetIdNotName,
3676	Expr,
3677	getText,
3678	isXML,
3679	contains,
3680	compile,
3681	sortOrder,
3682	hasDuplicate,
3683
3684	baseHasDuplicate = true,
3685	strundefined = "undefined",
3686
3687	expando = ( "sizcache" + Math.random() ).replace( ".", "" ),
3688
3689	document = window.document,
3690	docElem = document.documentElement,
3691	done = 0,
3692	slice = [].slice,
3693	push = [].push,
3694
3695	// Augment a function for special use by Sizzle
3696	markFunction = function( fn, value ) {
3697		fn[ expando ] = value || true;
3698		return fn;
3699	},
3700
3701	createCache = function() {
3702		var cache = {},
3703			keys = [];
3704
3705		return markFunction(function( key, value ) {
3706			// Only keep the most recent entries
3707			if ( keys.push( key ) > Expr.cacheLength ) {
3708				delete cache[ keys.shift() ];
3709			}
3710
3711			return (cache[ key ] = value);
3712		}, cache );
3713	},
3714
3715	classCache = createCache(),
3716	tokenCache = createCache(),
3717	compilerCache = createCache(),
3718
3719	// Regex
3720
3721	// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
3722	whitespace = "[\\x20\\t\\r\\n\\f]",
3723	// http://www.w3.org/TR/css3-syntax/#characters
3724	characterEncoding = "(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+",
3725
3726	// Loosely modeled on CSS identifier characters
3727	// An unquoted value should be a CSS identifier (http://www.w3.org/TR/css3-selectors/#attribute-selectors)
3728	// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
3729	identifier = characterEncoding.replace( "w", "w#" ),
3730
3731	// Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
3732	operators = "([*^$|!~]?=)",
3733	attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace +
3734		"*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",
3735
3736	// Prefer arguments not in parens/brackets,
3737	//   then attribute selectors and non-pseudos (denoted by :),
3738	//   then anything else
3739	// These preferences are here to reduce the number of selectors
3740	//   needing tokenize in the PSEUDO preFilter
3741	pseudos = ":(" + characterEncoding + ")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:" + attributes + ")|[^:]|\\\\.)*|.*))\\)|)",
3742
3743	// For matchExpr.POS and matchExpr.needsContext
3744	pos = ":(nth|eq|gt|lt|first|last|even|odd)(?:\\(((?:-\\d)?\\d*)\\)|)(?=[^-]|$)",
3745
3746	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
3747	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
3748
3749	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
3750	rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ),
3751	rpseudo = new RegExp( pseudos ),
3752
3753	// Easily-parseable/retrievable ID or TAG or CLASS selectors
3754	rquickExpr = /^(?:#([\w\-]+)|(\w+)|\.([\w\-]+))$/,
3755
3756	rnot = /^:not/,
3757	rsibling = /[\x20\t\r\n\f]*[+~]/,
3758	rendsWithNot = /:not\($/,
3759
3760	rheader = /h\d/i,
3761	rinputs = /input|select|textarea|button/i,
3762
3763	rbackslash = /\\(?!\\)/g,
3764
3765	matchExpr = {
3766		"ID": new RegExp( "^#(" + characterEncoding + ")" ),
3767		"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
3768		"NAME": new RegExp( "^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]" ),
3769		"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
3770		"ATTR": new RegExp( "^" + attributes ),
3771		"PSEUDO": new RegExp( "^" + pseudos ),
3772		"CHILD": new RegExp( "^:(only|nth|last|first)-child(?:\\(" + whitespace +
3773			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
3774			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
3775		"POS": new RegExp( pos, "ig" ),
3776		// For use in libraries implementing .is()
3777		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|" + pos, "i" )
3778	},
3779
3780	// Support
3781
3782	// Used for testing something on an element
3783	assert = function( fn ) {
3784		var div = document.createElement("div");
3785
3786		try {
3787			return fn( div );
3788		} catch (e) {
3789			return false;
3790		} finally {
3791			// release memory in IE
3792			div = null;
3793		}
3794	},
3795
3796	// Check if getElementsByTagName("*") returns only elements
3797	assertTagNameNoComments = assert(function( div ) {
3798		div.appendChild( document.createComment("") );
3799		return !div.getElementsByTagName("*").length;
3800	}),
3801
3802	// Check if getAttribute returns normalized href attributes
3803	assertHrefNotNormalized = assert(function( div ) {
3804		div.innerHTML = "<a href='#'></a>";
3805		return div.firstChild && typeof div.firstChild.getAttribute !== strundefined &&
3806			div.firstChild.getAttribute("href") === "#";
3807	}),
3808
3809	// Check if attributes should be retrieved by attribute nodes
3810	assertAttributes = assert(function( div ) {
3811		div.innerHTML = "<select></select>";
3812		var type = typeof div.lastChild.getAttribute("multiple");
3813		// IE8 returns a string for some attributes even when not present
3814		return type !== "boolean" && type !== "string";
3815	}),
3816
3817	// Check if getElementsByClassName can be trusted
3818	assertUsableClassName = assert(function( div ) {
3819		// Opera can't find a second classname (in 9.6)
3820		div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>";
3821		if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) {
3822			return false;
3823		}
3824
3825		// Safari 3.2 caches class attributes and doesn't catch changes
3826		div.lastChild.className = "e";
3827		return div.getElementsByClassName("e").length === 2;
3828	}),
3829
3830	// Check if getElementById returns elements by name
3831	// Check if getElementsByName privileges form controls or returns elements by ID
3832	assertUsableName = assert(function( div ) {
3833		// Inject content
3834		div.id = expando + 0;
3835		div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>";
3836		docElem.insertBefore( div, docElem.firstChild );
3837
3838		// Test
3839		var pass = document.getElementsByName &&
3840			// buggy browsers will return fewer than the correct 2
3841			document.getElementsByName( expando ).length === 2 +
3842			// buggy browsers will return more than the correct 0
3843			document.getElementsByName( expando + 0 ).length;
3844		assertGetIdNotName = !document.getElementById( expando );
3845
3846		// Cleanup
3847		docElem.removeChild( div );
3848
3849		return pass;
3850	});
3851
3852// If slice is not available, provide a backup
3853try {
3854	slice.call( docElem.childNodes, 0 )[0].nodeType;
3855} catch ( e ) {
3856	slice = function( i ) {
3857		var elem, results = [];
3858		for ( ; (elem = this[i]); i++ ) {
3859			results.push( elem );
3860		}
3861		return results;
3862	};
3863}
3864
3865function Sizzle( selector, context, results, seed ) {
3866	results = results || [];
3867	context = context || document;
3868	var match, elem, xml, m,
3869		nodeType = context.nodeType;
3870
3871	if ( nodeType !== 1 && nodeType !== 9 ) {
3872		return [];
3873	}
3874
3875	if ( !selector || typeof selector !== "string" ) {
3876		return results;
3877	}
3878
3879	xml = isXML( context );
3880
3881	if ( !xml && !seed ) {
3882		if ( (match = rquickExpr.exec( selector )) ) {
3883			// Speed-up: Sizzle("#ID")
3884			if ( (m = match[1]) ) {
3885				if ( nodeType === 9 ) {
3886					elem = context.getElementById( m );
3887					// Check parentNode to catch when Blackberry 4.6 returns
3888					// nodes that are no longer in the document #6963
3889					if ( elem && elem.parentNode ) {
3890						// Handle the case where IE, Opera, and Webkit return items
3891						// by name instead of ID
3892						if ( elem.id === m ) {
3893							results.push( elem );
3894							return results;
3895						}
3896					} else {
3897						return results;
3898					}
3899				} else {
3900					// Context is not a document
3901					if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
3902						contains( context, elem ) && elem.id === m ) {
3903						results.push( elem );
3904						return results;
3905					}
3906				}
3907
3908			// Speed-up: Sizzle("TAG")
3909			} else if ( match[2] ) {
3910				push.apply( results, slice.call(context.getElementsByTagName( selector ), 0) );
3911				return results;
3912
3913			// Speed-up: Sizzle(".CLASS")
3914			} else if ( (m = match[3]) && assertUsableClassName && context.getElementsByClassName ) {
3915				push.apply( results, slice.call(context.getElementsByClassName( m ), 0) );
3916				return results;
3917			}
3918		}
3919	}
3920
3921	// All others
3922	return select( selector, context, results, seed, xml );
3923}
3924
3925Sizzle.matches = function( expr, elements ) {
3926	return Sizzle( expr, null, null, elements );
3927};
3928
3929Sizzle.matchesSelector = function( elem, expr ) {
3930	return Sizzle( expr, null, null, [ elem ] ).length > 0;
3931};
3932
3933// Returns a function to use in pseudos for input types
3934function createInputPseudo( type ) {
3935	return function( elem ) {
3936		var name = elem.nodeName.toLowerCase();
3937		return name === "input" && elem.type === type;
3938	};
3939}
3940
3941// Returns a function to use in pseudos for buttons
3942function createButtonPseudo( type ) {
3943	return function( elem ) {
3944		var name = elem.nodeName.toLowerCase();
3945		return (name === "input" || name === "button") && elem.type === type;
3946	};
3947}
3948
3949/**
3950 * Utility function for retrieving the text value of an array of DOM nodes
3951 * @param {Array|Element} elem
3952 */
3953getText = Sizzle.getText = function( elem ) {
3954	var node,
3955		ret = "",
3956		i = 0,
3957		nodeType = elem.nodeType;
3958
3959	if ( nodeType ) {
3960		if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
3961			// Use textContent for elements
3962			// innerText usage removed for consistency of new lines (see #11153)
3963			if ( typeof elem.textContent === "string" ) {
3964				return elem.textContent;
3965			} else {
3966				// Traverse its children
3967				for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
3968					ret += getText( elem );
3969				}
3970			}
3971		} else if ( nodeType === 3 || nodeType === 4 ) {
3972			return elem.nodeValue;
3973		}
3974		// Do not include comment or processing instruction nodes
3975	} else {
3976
3977		// If no nodeType, this is expected to be an array
3978		for ( ; (node = elem[i]); i++ ) {
3979			// Do not traverse comment nodes
3980			ret += getText( node );
3981		}
3982	}
3983	return ret;
3984};
3985
3986isXML = Sizzle.isXML = function isXML( elem ) {
3987	// documentElement is verified for cases where it doesn't yet exist
3988	// (such as loading iframes in IE - #4833)
3989	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
3990	return documentElement ? documentElement.nodeName !== "HTML" : false;
3991};
3992
3993// Element contains another
3994contains = Sizzle.contains = docElem.contains ?
3995	function( a, b ) {
3996		var adown = a.nodeType === 9 ? a.documentElement : a,
3997			bup = b && b.parentNode;
3998		return a === bup || !!( bup && bup.nodeType === 1 && adown.contains && adown.contains(bup) );
3999	} :
4000	docElem.compareDocumentPosition ?
4001	function( a, b ) {
4002		return b && !!( a.compareDocumentPosition( b ) & 16 );
4003	} :
4004	function( a, b ) {
4005		while ( (b = b.parentNode) ) {
4006			if ( b === a ) {
4007				return true;
4008			}
4009		}
4010		return false;
4011	};
4012
4013Sizzle.attr = function( elem, name ) {
4014	var attr,
4015		xml = isXML( elem );
4016
4017	if ( !xml ) {
4018		name = name.toLowerCase();
4019	}
4020	if ( Expr.attrHandle[ name ] ) {
4021		return Expr.attrHandle[ name ]( elem );
4022	}
4023	if ( assertAttributes || xml ) {
4024		return elem.getAttribute( name );
4025	}
4026	attr = elem.getAttributeNode( name );
4027	return attr ?
4028		typeof elem[ name ] === "boolean" ?
4029			elem[ name ] ? name : null :
4030			attr.specified ? attr.value : null :
4031		null;
4032};
4033
4034Expr = Sizzle.selectors = {
4035
4036	// Can be adjusted by the user
4037	cacheLength: 50,
4038
4039	createPseudo: markFunction,
4040
4041	match: matchExpr,
4042
4043	order: new RegExp( "ID|TAG" +
4044		(assertUsableName ? "|NAME" : "") +
4045		(assertUsableClassName ? "|CLASS" : "")
4046	),
4047
4048	// IE6/7 return a modified href
4049	attrHandle: assertHrefNotNormalized ?
4050		{} :
4051		{
4052			"href": function( elem ) {
4053				return elem.getAttribute( "href", 2 );
4054			},
4055			"type": function( elem ) {
4056				return elem.getAttribute("type");
4057			}
4058		},
4059
4060	find: {
4061		"ID": assertGetIdNotName ?
4062			function( id, context, xml ) {
4063				if ( typeof context.getElementById !== strundefined && !xml ) {
4064					var m = context.getElementById( id );
4065					// Check parentNode to catch when Blackberry 4.6 returns
4066					// nodes that are no longer in the document #6963
4067					return m && m.parentNode ? [m] : [];
4068				}
4069			} :
4070			function( id, context, xml ) {
4071				if ( typeof context.getElementById !== strundefined && !xml ) {
4072					var m = context.getElementById( id );
4073
4074					return m ?
4075						m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ?
4076							[m] :
4077							undefined :
4078						[];
4079				}
4080			},
4081
4082		"TAG": assertTagNameNoComments ?
4083			function( tag, context ) {
4084				if ( typeof context.getElementsByTagName !== strundefined ) {
4085					return context.getElementsByTagName( tag );
4086				}
4087			} :
4088			function( tag, context ) {
4089				var results = context.getElementsByTagName( tag );
4090
4091				// Filter out possible comments
4092				if ( tag === "*" ) {
4093					var elem,
4094						tmp = [],
4095						i = 0;
4096
4097					for ( ; (elem = results[i]); i++ ) {
4098						if ( elem.nodeType === 1 ) {
4099							tmp.push( elem );
4100						}
4101					}
4102
4103					return tmp;
4104				}
4105				return results;
4106			},
4107
4108		"NAME": function( tag, context ) {
4109			if ( typeof context.getElementsByName !== strundefined ) {
4110				return context.getElementsByName( name );
4111			}
4112		},
4113
4114		"CLASS": function( className, context, xml ) {
4115			if ( typeof context.getElementsByClassName !== strundefined && !xml ) {
4116				return context.getElementsByClassName( className );
4117			}
4118		}
4119	},
4120
4121	relative: {
4122		">": { dir: "parentNode", first: true },
4123		" ": { dir: "parentNode" },
4124		"+": { dir: "previousSibling", first: true },
4125		"~": { dir: "previousSibling" }
4126	},
4127
4128	preFilter: {
4129		"ATTR": function( match ) {
4130			match[1] = match[1].replace( rbackslash, "" );
4131
4132			// Move the given value to match[3] whether quoted or unquoted
4133			match[3] = ( match[4] || match[5] || "" ).replace( rbackslash, "" );
4134
4135			if ( match[2] === "~=" ) {
4136				match[3] = " " + match[3] + " ";
4137			}
4138
4139			return match.slice( 0, 4 );
4140		},
4141
4142		"CHILD": function( match ) {
4143			/* matches from matchExpr.CHILD
4144				1 type (only|nth|...)