https://www.piccom.org/assets/application.js

1/*!
2 * jQuery JavaScript Library v1.7.2
3 * http://jquery.com/
4 *
5 * Copyright 2011, John Resig
6 * Dual licensed under the MIT or GPL Version 2 licenses.
7 * http://jquery.org/license
8 *
9 * Includes Sizzle.js
10 * http://sizzlejs.com/
11 * Copyright 2011, The Dojo Foundation
12 * Released under the MIT, BSD, and GPL Licenses.
13 *
14 * Date: Wed Mar 21 12:46:34 2012 -0700
15 */
16
17(function( window, undefined ) {
18
19// Use the correct document accordingly with window argument (sandbox)
20var document = window.document,
21	navigator = window.navigator,
22	location = window.location;
23var jQuery = (function() {
24
25// Define a local copy of jQuery
26var jQuery = function( selector, context ) {
27		// The jQuery object is actually just the init constructor 'enhanced'
28		return new jQuery.fn.init( selector, context, rootjQuery );
29	},
30
31	// Map over jQuery in case of overwrite
32	_jQuery = window.jQuery,
33
34	// Map over the $ in case of overwrite
35	_$ = window.$,
36
37	// A central reference to the root jQuery(document)
38	rootjQuery,
39
40	// A simple way to check for HTML strings or ID strings
41	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
42	quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
43
44	// Check if a string has a non-whitespace character in it
45	rnotwhite = /\S/,
46
47	// Used for trimming whitespace
48	trimLeft = /^\s+/,
49	trimRight = /\s+$/,
50
51	// Match a standalone tag
52	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
53
54	// JSON RegExp
55	rvalidchars = /^[\],:{}\s]*$/,
56	rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
57	rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
58	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
59
60	// Useragent RegExp
61	rwebkit = /(webkit)[ \/]([\w.]+)/,
62	ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
63	rmsie = /(msie) ([\w.]+)/,
64	rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
65
66	// Matches dashed string for camelizing
67	rdashAlpha = /-([a-z]|[0-9])/ig,
68	rmsPrefix = /^-ms-/,
69
70	// Used by jQuery.camelCase as callback to replace()
71	fcamelCase = function( all, letter ) {
72		return ( letter + "" ).toUpperCase();
73	},
74
75	// Keep a UserAgent string for use with jQuery.browser
76	userAgent = navigator.userAgent,
77
78	// For matching the engine and version of the browser
79	browserMatch,
80
81	// The deferred used on DOM ready
82	readyList,
83
84	// The ready event handler
85	DOMContentLoaded,
86
87	// Save a reference to some core methods
88	toString = Object.prototype.toString,
89	hasOwn = Object.prototype.hasOwnProperty,
90	push = Array.prototype.push,
91	slice = Array.prototype.slice,
92	trim = String.prototype.trim,
93	indexOf = Array.prototype.indexOf,
94
95	// [[Class]] -> type pairs
96	class2type = {};
97
98jQuery.fn = jQuery.prototype = {
99	constructor: jQuery,
100	init: function( selector, context, rootjQuery ) {
101		var match, elem, ret, doc;
102
103		// Handle $(""), $(null), or $(undefined)
104		if ( !selector ) {
105			return this;
106		}
107
108		// Handle $(DOMElement)
109		if ( selector.nodeType ) {
110			this.context = this[0] = selector;
111			this.length = 1;
112			return this;
113		}
114
115		// The body element only exists once, optimize finding it
116		if ( selector === "body" && !context && document.body ) {
117			this.context = document;
118			this[0] = document.body;
119			this.selector = selector;
120			this.length = 1;
121			return this;
122		}
123
124		// Handle HTML strings
125		if ( typeof selector === "string" ) {
126			// Are we dealing with HTML string or an ID?
127			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
128				// Assume that strings that start and end with <> are HTML and skip the regex check
129				match = [ null, selector, null ];
130
131			} else {
132				match = quickExpr.exec( selector );
133			}
134
135			// Verify a match, and that no context was specified for #id
136			if ( match && (match[1] || !context) ) {
137
138				// HANDLE: $(html) -> $(array)
139				if ( match[1] ) {
140					context = context instanceof jQuery ? context[0] : context;
141					doc = ( context ? context.ownerDocument || context : document );
142
143					// If a single string is passed in and it's a single tag
144					// just do a createElement and skip the rest
145					ret = rsingleTag.exec( selector );
146
147					if ( ret ) {
148						if ( jQuery.isPlainObject( context ) ) {
149							selector = [ document.createElement( ret[1] ) ];
150							jQuery.fn.attr.call( selector, context, true );
151
152						} else {
153							selector = [ doc.createElement( ret[1] ) ];
154						}
155
156					} else {
157						ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
158						selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes;
159					}
160
161					return jQuery.merge( this, selector );
162
163				// HANDLE: $("#id")
164				} else {
165					elem = document.getElementById( match[2] );
166
167					// Check parentNode to catch when Blackberry 4.6 returns
168					// nodes that are no longer in the document #6963
169					if ( elem && elem.parentNode ) {
170						// Handle the case where IE and Opera return items
171						// by name instead of ID
172						if ( elem.id !== match[2] ) {
173							return rootjQuery.find( selector );
174						}
175
176						// Otherwise, we inject the element directly into the jQuery object
177						this.length = 1;
178						this[0] = elem;
179					}
180
181					this.context = document;
182					this.selector = selector;
183					return this;
184				}
185
186			// HANDLE: $(expr, $(...))
187			} else if ( !context || context.jquery ) {
188				return ( context || rootjQuery ).find( selector );
189
190			// HANDLE: $(expr, context)
191			// (which is just equivalent to: $(context).find(expr)
192			} else {
193				return this.constructor( context ).find( selector );
194			}
195
196		// HANDLE: $(function)
197		// Shortcut for document ready
198		} else if ( jQuery.isFunction( selector ) ) {
199			return rootjQuery.ready( selector );
200		}
201
202		if ( selector.selector !== undefined ) {
203			this.selector = selector.selector;
204			this.context = selector.context;
205		}
206
207		return jQuery.makeArray( selector, this );
208	},
209
210	// Start with an empty selector
211	selector: "",
212
213	// The current version of jQuery being used
214	jquery: "1.7.2",
215
216	// The default length of a jQuery object is 0
217	length: 0,
218
219	// The number of elements contained in the matched element set
220	size: function() {
221		return this.length;
222	},
223
224	toArray: function() {
225		return slice.call( this, 0 );
226	},
227
228	// Get the Nth element in the matched element set OR
229	// Get the whole matched element set as a clean array
230	get: function( num ) {
231		return num == null ?
232
233			// Return a 'clean' array
234			this.toArray() :
235
236			// Return just the object
237			( num < 0 ? this[ this.length + num ] : this[ num ] );
238	},
239
240	// Take an array of elements and push it onto the stack
241	// (returning the new matched element set)
242	pushStack: function( elems, name, selector ) {
243		// Build a new jQuery matched element set
244		var ret = this.constructor();
245
246		if ( jQuery.isArray( elems ) ) {
247			push.apply( ret, elems );
248
249		} else {
250			jQuery.merge( ret, elems );
251		}
252
253		// Add the old object onto the stack (as a reference)

254		ret.prevObject = this;
255
256		ret.context = this.context;
257
258		if ( name === "find" ) {
259			ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
260		} else if ( name ) {
261			ret.selector = this.selector + "." + name + "(" + selector + ")";
262		}
263
264		// Return the newly-formed element set
265		return ret;
266	},
267
268	// Execute a callback for every element in the matched set.
269	// (You can seed the arguments with an array of args, but this is
270	// only used internally.)
271	each: function( callback, args ) {
272		return jQuery.each( this, callback, args );
273	},
274
275	ready: function( fn ) {
276		// Attach the listeners
277		jQuery.bindReady();
278
279		// Add the callback
280		readyList.add( fn );
281
282		return this;
283	},
284
285	eq: function( i ) {
286		i = +i;
287		return i === -1 ?
288			this.slice( i ) :
289			this.slice( i, i + 1 );
290	},
291
292	first: function() {
293		return this.eq( 0 );
294	},
295
296	last: function() {
297		return this.eq( -1 );
298	},
299
300	slice: function() {
301		return this.pushStack( slice.apply( this, arguments ),
302			"slice", slice.call(arguments).join(",") );
303	},
304
305	map: function( callback ) {
306		return this.pushStack( jQuery.map(this, function( elem, i ) {
307			return callback.call( elem, i, elem );
308		}));
309	},
310
311	end: function() {
312		return this.prevObject || this.constructor(null);
313	},
314
315	// For internal use only.
316	// Behaves like an Array's method, not like a jQuery method.
317	push: push,
318	sort: [].sort,
319	splice: [].splice
320};
321
322// Give the init function the jQuery prototype for later instantiation
323jQuery.fn.init.prototype = jQuery.fn;
324
325jQuery.extend = jQuery.fn.extend = function() {
326	var options, name, src, copy, copyIsArray, clone,
327		target = arguments[0] || {},
328		i = 1,
329		length = arguments.length,
330		deep = false;
331
332	// Handle a deep copy situation
333	if ( typeof target === "boolean" ) {
334		deep = target;
335		target = arguments[1] || {};
336		// skip the boolean and the target
337		i = 2;
338	}
339
340	// Handle case when target is a string or something (possible in deep copy)
341	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
342		target = {};
343	}
344
345	// extend jQuery itself if only one argument is passed
346	if ( length === i ) {
347		target = this;
348		--i;
349	}
350
351	for ( ; i < length; i++ ) {
352		// Only deal with non-null/undefined values
353		if ( (options = arguments[ i ]) != null ) {
354			// Extend the base object
355			for ( name in options ) {
356				src = target[ name ];
357				copy = options[ name ];
358
359				// Prevent never-ending loop
360				if ( target === copy ) {
361					continue;
362				}
363
364				// Recurse if we're merging plain objects or arrays
365				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
366					if ( copyIsArray ) {
367						copyIsArray = false;
368						clone = src && jQuery.isArray(src) ? src : [];
369
370					} else {
371						clone = src && jQuery.isPlainObject(src) ? src : {};
372					}
373
374					// Never move original objects, clone them
375					target[ name ] = jQuery.extend( deep, clone, copy );
376
377				// Don't bring in undefined values
378				} else if ( copy !== undefined ) {
379					target[ name ] = copy;
380				}
381			}
382		}
383	}
384
385	// Return the modified object
386	return target;
387};
388
389jQuery.extend({
390	noConflict: function( deep ) {
391		if ( window.$ === jQuery ) {
392			window.$ = _$;
393		}
394
395		if ( deep && window.jQuery === jQuery ) {
396			window.jQuery = _jQuery;
397		}
398
399		return jQuery;
400	},
401
402	// Is the DOM ready to be used? Set to true once it occurs.
403	isReady: false,
404
405	// A counter to track how many items to wait for before
406	// the ready event fires. See #6781
407	readyWait: 1,
408
409	// Hold (or release) the ready event
410	holdReady: function( hold ) {
411		if ( hold ) {
412			jQuery.readyWait++;
413		} else {
414			jQuery.ready( true );
415		}
416	},
417
418	// Handle when the DOM is ready
419	ready: function( wait ) {
420		// Either a released hold or an DOMready/load event and not yet ready
421		if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
422			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
423			if ( !document.body ) {
424				return setTimeout( jQuery.ready, 1 );
425			}
426
427			// Remember that the DOM is ready
428			jQuery.isReady = true;
429
430			// If a normal DOM Ready event fired, decrement, and wait if need be
431			if ( wait !== true && --jQuery.readyWait > 0 ) {
432				return;
433			}
434

435			// If there are functions bound, to execute
436			readyList.fireWith( document, [ jQuery ] );
437
438			// Trigger any bound ready events
439			if ( jQuery.fn.trigger ) {
440				jQuery( document ).trigger( "ready" ).off( "ready" );
441			}
442		}
443	},
444
445	bindReady: function() {
446		if ( readyList ) {
447			return;
448		}
449
450		readyList = jQuery.Callbacks( "once memory" );
451
452		// Catch cases where $(document).ready() is called after the
453		// browser event has already occurred.
454		if ( document.readyState === "complete" ) {
455			// Handle it asynchronously to allow scripts the opportunity to delay ready
456			return setTimeout( jQuery.ready, 1 );
457		}
458
459		// Mozilla, Opera and webkit nightlies currently support this event
460		if ( document.addEventListener ) {
461			// Use the handy event callback
462			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
463
464			// A fallback to window.onload, that will always work
465			window.addEventListener( "load", jQuery.ready, false );
466
467		// If IE event model is used
468		} else if ( document.attachEvent ) {
469			// ensure firing before onload,
470			// maybe late but safe also for iframes
471			document.attachEvent( "onreadystatechange", DOMContentLoaded );
472
473			// A fallback to window.onload, that will always work
474			window.attachEvent( "onload", jQuery.ready );
475
476			// If IE and not a frame
477			// continually check to see if the document is ready
478			var toplevel = false;
479
480			try {
481				toplevel = window.frameElement == null;
482			} catch(e) {}
483
484			if ( document.documentElement.doScroll && toplevel ) {
485				doScrollCheck();
486			}
487		}
488	},
489
490	// See test/unit/core.js for details concerning isFunction.
491	// Since version 1.3, DOM methods and functions like alert
492	// aren't supported. They return false on IE (#2968).
493	isFunction: function( obj ) {
494		return jQuery.type(obj) === "function";
495	},
496
497	isArray: Array.isArray || function( obj ) {
498		return jQuery.type(obj) === "array";
499	},
500
501	isWindow: function( obj ) {
502		return obj != null && obj == obj.window;
503	},
504
505	isNumeric: function( obj ) {
506		return !isNaN( parseFloat(obj) ) && isFinite( obj );
507	},
508
509	type: function( obj ) {
510		return obj == null ?
511			String( obj ) :
512			class2type[ toString.call(obj) ] || "object";
513	},
514
515	isPlainObject: function( obj ) {
516		// Must be an Object.
517		// Because of IE, we also have to check the presence of the constructor property.
518		// Make sure that DOM nodes and window objects don't pass through, as well
519		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
520			return false;
521		}
522
523		try {
524			// Not own constructor property must be Object
525			if ( obj.constructor &&
526				!hasOwn.call(obj, "constructor") &&
527				!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
528				return false;
529			}
530		} catch ( e ) {
531			// IE8,9 Will throw exceptions on certain host objects #9897
532			return false;
533		}
534
535		// Own properties are enumerated firstly, so to speed up,
536		// if last one is own, then all properties are own.
537
538		var key;
539		for ( key in obj ) {}
540
541		return key === undefined || hasOwn.call( obj, key );
542	},
543
544	isEmptyObject: function( obj ) {
545		for ( var name in obj ) {
546			return false;
547		}
548		return true;
549	},
550
551	error: function( msg ) {
552		throw new Error( msg );
553	},
554
555	parseJSON: function( data ) {
556		if ( typeof data !== "string" || !data ) {
557			return null;
558		}
559
560		// Make sure leading/trailing whitespace is removed (IE can't handle it)
561		data = jQuery.trim( data );
562
563		// Attempt to parse using the native JSON parser first
564		if ( window.JSON && window.JSON.parse ) {
565			return window.JSON.parse( data );
566		}
567
568		// Make sure the incoming data is actual JSON
569		// Logic borrowed from http://json.org/json2.js
570		if ( rvalidchars.test( data.replace( rvalidescape, "@" )
571			.replace( rvalidtokens, "]" )
572			.replace( rvalidbraces, "")) ) {
573
574			return ( new Function( "return " + data ) )();
575
576		}
577		jQuery.error( "Invalid JSON: " + data );
578	},
579
580	// Cross-browser xml parsing
581	parseXML: function( data ) {
582		if ( typeof data !== "string" || !data ) {
583			return null;
584		}
585		var xml, tmp;
586		try {
587			if ( window.DOMParser ) { // Standard
588				tmp = new DOMParser();
589				xml = tmp.parseFromString( data , "text/xml" );
590			} else { // IE
591				xml = new ActiveXObject( "Microsoft.XMLDOM" );
592				xml.async = "false";
593				xml.loadXML( data );
594			}
595		} catch( e ) {
596			xml = undefined;
597		}
598		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
599			jQuery.error( "Invalid XML: " + data );
600		}
601		return xml;
602	},
603
604	noop: function() {},
605
606	// Evaluates a script in a global context
607	// Workarounds based on findings by Jim Driscoll
608	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
609	globalEval: function( data ) {
610		if ( data && rnotwhite.test( data ) ) {
611			// We use execScript on Internet Explorer
612			// We use an anonymous function so that context is window
613			// rather than jQuery in Firefox
614			( window.execScript || function( data ) {
615				window[ "eval" ].call( window, data );
616			} )( data );
617		}
618	},
619
620	// Convert dashed to camelCase; used by the css and data modules
621	// Microsoft forgot to hump their vendor prefix (#9572)
622	camelCase: function( string ) {
623		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
624	},
625

626	nodeName: function( elem, name ) {
627		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
628	},
629
630	// args is for internal usage only
631	each: function( object, callback, args ) {
632		var name, i = 0,
633			length = object.length,
634			isObj = length === undefined || jQuery.isFunction( object );
635
636		if ( args ) {
637			if ( isObj ) {
638				for ( name in object ) {
639					if ( callback.apply( object[ name ], args ) === false ) {
640						break;
641					}
642				}
643			} else {
644				for ( ; i < length; ) {
645					if ( callback.apply( object[ i++ ], args ) === false ) {
646						break;
647					}
648				}
649			}
650
651		// A special, fast, case for the most common use of each
652		} else {
653			if ( isObj ) {
654				for ( name in object ) {
655					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
656						break;
657					}
658				}
659			} else {
660				for ( ; i < length; ) {
661					if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
662						break;
663					}
664				}
665			}
666		}
667
668		return object;
669	},
670
671	// Use native String.trim function wherever possible
672	trim: trim ?
673		function( text ) {
674			return text == null ?
675				"" :
676				trim.call( text );
677		} :
678
679		// Otherwise use our own trimming functionality
680		function( text ) {
681			return text == null ?
682				"" :
683				text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
684		},
685
686	// results is for internal usage only
687	makeArray: function( array, results ) {
688		var ret = results || [];
689
690		if ( array != null ) {
691			// The window, strings (and functions) also have 'length'
692			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
693			var type = jQuery.type( array );
694
695			if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
696				push.call( ret, array );
697			} else {
698				jQuery.merge( ret, array );
699			}
700		}
701
702		return ret;
703	},
704
705	inArray: function( elem, array, i ) {
706		var len;
707
708		if ( array ) {
709			if ( indexOf ) {
710				return indexOf.call( array, elem, i );
711			}
712
713			len = array.length;
714			i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
715
716			for ( ; i < len; i++ ) {
717				// Skip accessing in sparse arrays
718				if ( i in array && array[ i ] === elem ) {
719					return i;
720				}
721			}
722		}
723
724		return -1;
725	},
726
727	merge: function( first, second ) {
728		var i = first.length,
729			j = 0;
730
731		if ( typeof second.length === "number" ) {
732			for ( var l = second.length; j < l; j++ ) {
733				first[ i++ ] = second[ j ];
734			}
735
736		} else {
737			while ( second[j] !== undefined ) {
738				first[ i++ ] = second[ j++ ];
739			}
740		}
741
742		first.length = i;
743
744		return first;
745	},
746
747	grep: function( elems, callback, inv ) {
748		var ret = [], retVal;
749		inv = !!inv;
750
751		// Go through the array, only saving the items
752		// that pass the validator function
753		for ( var i = 0, length = elems.length; i < length; i++ ) {
754			retVal = !!callback( elems[ i ], i );
755			if ( inv !== retVal ) {
756				ret.push( elems[ i ] );
757			}
758		}
759
760		return ret;
761	},
762
763	// arg is for internal usage only
764	map: function( elems, callback, arg ) {
765		var value, key, ret = [],
766			i = 0,
767			length = elems.length,
768			// jquery objects are treated as arrays
769			isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
770
771		// Go through the array, translating each of the items to their
772		if ( isArray ) {
773			for ( ; i < length; i++ ) {
774				value = callback( elems[ i ], i, arg );
775
776				if ( value != null ) {
777					ret[ ret.length ] = value;
778				}
779			}
780
781		// Go through every key on the object,
782		} else {
783			for ( key in elems ) {
784				value = callback( elems[ key ], key, arg );
785
786				if ( value != null ) {
787					ret[ ret.length ] = value;
788				}
789			}
790		}
791
792		// Flatten any nested arrays
793		return ret.concat.apply( [], ret );
794	},
795
796	// A global GUID counter for objects
797	guid: 1,
798
799	// Bind a function to a context, optionally partially applying any
800	// arguments.
801	proxy: function( fn, context ) {
802		if ( typeof context === "string" ) {
803			var tmp = fn[ context ];
804			context = fn;
805			fn = tmp;
806		}
807
808		// Quick check to determine if target is callable, in the spec
809		// this throws a TypeError, but we will just return undefined.
810		if ( !jQuery.isFunction( fn ) ) {
811			return undefined;
812		}
813
814		// Simulated bind
815		var args = slice.call( arguments, 2 ),
816			proxy = function() {
817				return fn.apply( context, args.concat( slice.call( arguments ) ) );
818			};
819
820		// Set the guid of unique handler to the same of original handler, so it can be removed
821		proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
822
823		return proxy;
824	},
825
826	// Mutifunctional method to get and set values to a collection
827	// The value/s can optionally be executed if it's a function
828	access: function( elems, fn, key, value, chainable, emptyGet, pass ) {
829		var exec,
830			bulk = key == null,
831			i = 0,
832			length = elems.length;
833
834		// Sets many values
835		if ( key && typeof key === "object" ) {
836			for ( i in key ) {
837				jQuery.access( elems, fn, i, key[i], 1, emptyGet, value );
838			}
839			chainable = 1;
840
841		// Sets one value
842		} else if ( value !== undefined ) {
843			// Optionally, function values get executed if exec is true
844			exec = pass === undefined && jQuery.isFunction( value );
845
846			if ( bulk ) {
847				// Bulk operations only iterate when executing function values
848				if ( exec ) {
849					exec = fn;
850					fn = function( elem, key, value ) {
851						return exec.call( jQuery( elem ), value );
852					};
853
854				// Otherwise they run against the entire set
855				} else {
856					fn.call( elems, value );
857					fn = null;
858				}
859			}
860
861			if ( fn ) {
862				for (; i < length; i++ ) {
863					fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
864				}
865			}
866
867			chainable = 1;
868		}
869
870		return chainable ?
871			elems :
872
873			// Gets
874			bulk ?
875				fn.call( elems ) :
876				length ? fn( elems[0], key ) : emptyGet;
877	},
878
879	now: function() {
880		return ( new Date() ).getTime();
881	},
882
883	// Use of jQuery.browser is frowned upon.
884	// More details: http://docs.jquery.com/Utilities/jQuery.browser
885	uaMatch: function( ua ) {
886		ua = ua.toLowerCase();
887
888		var match = rwebkit.exec( ua ) ||
889			ropera.exec( ua ) ||
890			rmsie.exec( ua ) ||
891			ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
892			[];
893
894		return { browser: match[1] || "", version: match[2] || "0" };
895	},
896
897	sub: function() {
898		function jQuerySub( selector, context ) {
899			return new jQuerySub.fn.init( selector, context );
900		}
901		jQuery.extend( true, jQuerySub, this );
902		jQuerySub.superclass = this;
903		jQuerySub.fn = jQuerySub.prototype = this();
904		jQuerySub.fn.constructor = jQuerySub;
905		jQuerySub.sub = this.sub;
906		jQuerySub.fn.init = function init( selector, context ) {
907			if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
908				context = jQuerySub( context );
909			}
910
911			return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
912		};
913		jQuerySub.fn.init.prototype = jQuerySub.fn;
914		var rootjQuerySub = jQuerySub(document);
915		return jQuerySub;
916	},
917
918	browser: {}
919});
920
921// Populate the class2type map
922jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
923	class2type[ "[object " + name + "]" ] = name.toLowerCase();
924});
925
926browserMatch = jQuery.uaMatch( userAgent );
927if ( browserMatch.browser ) {
928	jQuery.browser[ browserMatch.browser ] = true;
929	jQuery.browser.version = browserMatch.version;
930}
931
932// Deprecated, use jQuery.browser.webkit instead
933if ( jQuery.browser.webkit ) {
934	jQuery.browser.safari = true;
935}
936

937// IE doesn't match non-breaking spaces with \s
938if ( rnotwhite.test( "\xA0" ) ) {
939	trimLeft = /^[\s\xA0]+/;
940	trimRight = /[\s\xA0]+$/;
941}
942
943// All jQuery objects should point back to these
944rootjQuery = jQuery(document);
945
946// Cleanup functions for the document ready method
947if ( document.addEventListener ) {
948	DOMContentLoaded = function() {
949		document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
950		jQuery.ready();
951	};
952
953} else if ( document.attachEvent ) {
954	DOMContentLoaded = function() {
955		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
956		if ( document.readyState === "complete" ) {
957			document.detachEvent( "onreadystatechange", DOMContentLoaded );
958			jQuery.ready();
959		}
960	};
961}
962
963// The DOM ready check for Internet Explorer
964function doScrollCheck() {
965	if ( jQuery.isReady ) {
966		return;
967	}
968
969	try {
970		// If IE is used, use the trick by Diego Perini
971		// http://javascript.nwbox.com/IEContentLoaded/
972		document.documentElement.doScroll("left");
973	} catch(e) {
974		setTimeout( doScrollCheck, 1 );
975		return;
976	}
977
978	// and execute any waiting functions
979	jQuery.ready();
980}
981
982return jQuery;
983
984})();
985
986
987// String to Object flags format cache
988var flagsCache = {};
989
990// Convert String-formatted flags into Object-formatted ones and store in cache
991function createFlags( flags ) {
992	var object = flagsCache[ flags ] = {},
993		i, length;
994	flags = flags.split( /\s+/ );
995	for ( i = 0, length = flags.length; i < length; i++ ) {
996		object[ flags[i] ] = true;
997	}
998	return object;
999}
1000
1001/*
1002 * Create a callback list using the following parameters:
1003 *
1004 *	flags:	an optional list of space-separated flags that will change how
1005 *			the callback list behaves
1006 *
1007 * By default a callback list will act like an event callback list and can be
1008 * "fired" multiple times.
1009 *
1010 * Possible flags:
1011 *
1012 *	once:			will ensure the callback list can only be fired once (like a Deferred)
1013 *
1014 *	memory:			will keep track of previous values and will call any callback added
1015 *					after the list has been fired right away with the latest "memorized"
1016 *					values (like a Deferred)
1017 *
1018 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
1019 *
1020 *	stopOnFalse:	interrupt callings when a callback returns false
1021 *
1022 */
1023jQuery.Callbacks = function( flags ) {
1024
1025	// Convert flags from String-formatted to Object-formatted
1026	// (we check in cache first)
1027	flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {};
1028
1029	var // Actual callback list
1030		list = [],
1031		// Stack of fire calls for repeatable lists
1032		stack = [],
1033		// Last fire value (for non-forgettable lists)
1034		memory,
1035		// Flag to know if list was already fired
1036		fired,
1037		// Flag to know if list is currently firing
1038		firing,
1039		// First callback to fire (used internally by add and fireWith)
1040		firingStart,
1041		// End of the loop when firing
1042		firingLength,
1043		// Index of currently firing callback (modified by remove if needed)
1044		firingIndex,
1045		// Add one or several callbacks to the list
1046		add = function( args ) {
1047			var i,
1048				length,
1049				elem,
1050				type,
1051				actual;
1052			for ( i = 0, length = args.length; i < length; i++ ) {
1053				elem = args[ i ];
1054				type = jQuery.type( elem );
1055				if ( type === "array" ) {
1056					// Inspect recursively
1057					add( elem );
1058				} else if ( type === "function" ) {
1059					// Add if not in unique mode and callback is not in
1060					if ( !flags.unique || !self.has( elem ) ) {
1061						list.push( elem );
1062					}
1063				}
1064			}
1065		},
1066		// Fire callbacks
1067		fire = function( context, args ) {
1068			args = args || [];
1069			memory = !flags.memory || [ context, args ];
1070			fired = true;
1071			firing = true;
1072			firingIndex = firingStart || 0;
1073			firingStart = 0;
1074			firingLength = list.length;
1075			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
1076				if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) {
1077					memory = true; // Mark as halted
1078					break;
1079				}
1080			}
1081			firing = false;
1082			if ( list ) {
1083				if ( !flags.once ) {
1084					if ( stack && stack.length ) {
1085						memory = stack.shift();
1086						self.fireWith( memory[ 0 ], memory[ 1 ] );
1087					}
1088				} else if ( memory === true ) {
1089					self.disable();
1090				} else {
1091					list = [];
1092				}
1093			}
1094		},
1095		// Actual Callbacks object
1096		self = {
1097			// Add a callback or a collection of callbacks to the list
1098			add: function() {
1099				if ( list ) {
1100					var length = list.length;
1101					add( arguments );
1102					// Do we need to add the callbacks to the
1103					// current firing batch?
1104					if ( firing ) {
1105						firingLength = list.length;
1106					// With memory, if we're not firing then
1107					// we should call right away, unless previous
1108					// firing was halted (stopOnFalse)
1109					} else if ( memory && memory !== true ) {
1110						firingStart = length;
1111						fire( memory[ 0 ], memory[ 1 ] );
1112					}
1113				}
1114				return this;
1115			},
1116			// Remove a callback from the list
1117			remove: function() {
1118				if ( list ) {
1119					var args = arguments,
1120						argIndex = 0,
1121						argLength = args.length;
1122					for ( ; argIndex < argLength ; argIndex++ ) {
1123						for ( var i = 0; i < list.length; i++ ) {
1124							if ( args[ argIndex ] === list[ i ] ) {
1125								// Handle firingIndex and firingLength
1126								if ( firing ) {
1127									if ( i <= firingLength ) {
1128										firingLength--;
1129										if ( i <= firingIndex ) {
1130											firingIndex--;
1131										}
1132									}
1133								}
1134								// Remove the element
1135								list.splice( i--, 1 );
1136								// If we have some unicity property then
1137								// we only need to do this once
1138								if ( flags.unique ) {
1139									break;
1140								}
1141							}
1142						}
1143					}
1144				}
1145				return this;
1146			},
1147			// Control if a given callback is in the list
1148			has: function( fn ) {
1149				if ( list ) {
1150					var i = 0,
1151						length = list.length;
1152					for ( ; i < length; i++ ) {
1153						if ( fn === list[ i ] ) {
1154							return true;
1155						}
1156					}
1157				}
1158				return false;

1159			},
1160			// Remove all callbacks from the list
1161			empty: function() {
1162				list = [];
1163				return this;
1164			},
1165			// Have the list do nothing anymore
1166			disable: function() {
1167				list = stack = memory = undefined;
1168				return this;
1169			},
1170			// Is it disabled?
1171			disabled: function() {
1172				return !list;
1173			},
1174			// Lock the list in its current state
1175			lock: function() {
1176				stack = undefined;
1177				if ( !memory || memory === true ) {
1178					self.disable();
1179				}
1180				return this;
1181			},
1182			// Is it locked?
1183			locked: function() {
1184				return !stack;
1185			},
1186			// Call all callbacks with the given context and arguments
1187			fireWith: function( context, args ) {
1188				if ( stack ) {
1189					if ( firing ) {
1190						if ( !flags.once ) {
1191							stack.push( [ context, args ] );
1192						}
1193					} else if ( !( flags.once && memory ) ) {
1194						fire( context, args );
1195					}
1196				}
1197				return this;
1198			},
1199			// Call all the callbacks with the given arguments
1200			fire: function() {
1201				self.fireWith( this, arguments );
1202				return this;
1203			},
1204			// To know if the callbacks have already been called at least once
1205			fired: function() {
1206				return !!fired;
1207			}
1208		};
1209
1210	return self;
1211};
1212
1213
1214
1215
1216var // Static reference to slice
1217	sliceDeferred = [].slice;
1218
1219jQuery.extend({
1220
1221	Deferred: function( func ) {
1222		var doneList = jQuery.Callbacks( "once memory" ),
1223			failList = jQuery.Callbacks( "once memory" ),
1224			progressList = jQuery.Callbacks( "memory" ),
1225			state = "pending",
1226			lists = {
1227				resolve: doneList,
1228				reject: failList,
1229				notify: progressList
1230			},
1231			promise = {
1232				done: doneList.add,
1233				fail: failList.add,
1234				progress: progressList.add,
1235
1236				state: function() {
1237					return state;
1238				},
1239
1240				// Deprecated
1241				isResolved: doneList.fired,
1242				isRejected: failList.fired,
1243
1244				then: function( doneCallbacks, failCallbacks, progressCallbacks ) {
1245					deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks );
1246					return this;
1247				},
1248				always: function() {
1249					deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments );
1250					return this;
1251				},
1252				pipe: function( fnDone, fnFail, fnProgress ) {
1253					return jQuery.Deferred(function( newDefer ) {
1254						jQuery.each( {
1255							done: [ fnDone, "resolve" ],
1256							fail: [ fnFail, "reject" ],
1257							progress: [ fnProgress, "notify" ]
1258						}, function( handler, data ) {
1259							var fn = data[ 0 ],
1260								action = data[ 1 ],
1261								returned;
1262							if ( jQuery.isFunction( fn ) ) {
1263								deferred[ handler ](function() {
1264									returned = fn.apply( this, arguments );
1265									if ( returned && jQuery.isFunction( returned.promise ) ) {
1266										returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify );
1267									} else {
1268										newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
1269									}
1270								});
1271							} else {
1272								deferred[ handler ]( newDefer[ action ] );
1273							}
1274						});
1275					}).promise();
1276				},
1277				// Get a promise for this deferred
1278				// If obj is provided, the promise aspect is added to the object
1279				promise: function( obj ) {
1280					if ( obj == null ) {
1281						obj = promise;
1282					} else {
1283						for ( var key in promise ) {
1284							obj[ key ] = promise[ key ];
1285						}
1286					}
1287					return obj;
1288				}
1289			},
1290			deferred = promise.promise({}),
1291			key;
1292
1293		for ( key in lists ) {
1294			deferred[ key ] = lists[ key ].fire;
1295			deferred[ key + "With" ] = lists[ key ].fireWith;
1296		}
1297
1298		// Handle state
1299		deferred.done( function() {
1300			state = "resolved";
1301		}, failList.disable, progressList.lock ).fail( function() {
1302			state = "rejected";
1303		}, doneList.disable, progressList.lock );
1304
1305		// Call given func if any
1306		if ( func ) {
1307			func.call( deferred, deferred );
1308		}
1309
1310		// All done!
1311		return deferred;
1312	},
1313
1314	// Deferred helper
1315	when: function( firstParam ) {
1316		var args = sliceDeferred.call( arguments, 0 ),
1317			i = 0,
1318			length = args.length,
1319			pValues = new Array( length ),
1320			count = length,
1321			pCount = length,
1322			deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
1323				firstParam :
1324				jQuery.Deferred(),
1325			promise = deferred.promise();
1326		function resolveFunc( i ) {
1327			return function( value ) {
1328				args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1329				if ( !( --count ) ) {
1330					deferred.resolveWith( deferred, args );
1331				}
1332			};
1333		}
1334		function progressFunc( i ) {
1335			return function( value ) {
1336				pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1337				deferred.notifyWith( promise, pValues );
1338			};
1339		}
1340		if ( length > 1 ) {
1341			for ( ; i < length; i++ ) {
1342				if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) {
1343					args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) );
1344				} else {
1345					--count;
1346				}
1347			}
1348			if ( !count ) {
1349				deferred.resolveWith( deferred, args );
1350			}
1351		} else if ( deferred !== firstParam ) {
1352			deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
1353		}
1354		return promise;
1355	}
1356});
1357
1358
1359
1360
1361jQuery.support = (function() {
1362
1363	var support,
1364		all,
1365		a,
1366		select,
1367		opt,
1368		input,
1369		fragment,
1370		tds,
1371		events,
1372		eventName,
1373		i,
1374		isSupported,
1375		div = document.createElement( "div" ),
1376		documentElement = document.documentElement;
1377
1378	// Preliminary tests
1379	div.setAttribute("className", "t");
1380	div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a>

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

1505	support.appendChecked = input.checked;
1506
1507	fragment.removeChild( input );
1508	fragment.appendChild( div );
1509
1510	// Technique from Juriy Zaytsev
1511	// http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
1512	// We only care about the case where non-standard event systems
1513	// are used, namely in IE. Short-circuiting here helps us to
1514	// avoid an eval call (in setAttribute) which can cause CSP
1515	// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1516	if ( div.attachEvent ) {
1517		for ( i in {
1518			submit: 1,
1519			change: 1,
1520			focusin: 1
1521		}) {
1522			eventName = "on" + i;
1523			isSupported = ( eventName in div );
1524			if ( !isSupported ) {
1525				div.setAttribute( eventName, "return;" );
1526				isSupported = ( typeof div[ eventName ] === "function" );
1527			}
1528			support[ i + "Bubbles" ] = isSupported;
1529		}
1530	}
1531
1532	fragment.removeChild( div );
1533
1534	// Null elements to avoid leaks in IE
1535	fragment = select = opt = div = input = null;
1536
1537	// Run tests that need a body at doc ready
1538	jQuery(function() {
1539		var container, outer, inner, table, td, offsetSupport,
1540			marginDiv, conMarginTop, style, html, positionTopLeftWidthHeight,
1541			paddingMarginBorderVisibility, paddingMarginBorder,
1542			body = document.getElementsByTagName("body")[0];
1543
1544		if ( !body ) {
1545			// Return for frameset docs that don't have a body
1546			return;
1547		}
1548
1549		conMarginTop = 1;
1550		paddingMarginBorder = "padding:0;margin:0;border:";
1551		positionTopLeftWidthHeight = "position:absolute;top:0;left:0;width:1px;height:1px;";
1552		paddingMarginBorderVisibility = paddingMarginBorder + "0;visibility:hidden;";
1553		style = "style='" + positionTopLeftWidthHeight + paddingMarginBorder + "5px solid #000;";
1554		html = "<div " + style + "display:block;'><div style='" + paddingMarginBorder + "0;display:block;overflow:hidden;'></div></div>" +
1555			"<table " + style + "' cellpadding='0' cellspacing='0'>" +
1556			"<tr><td></td></tr></table>";
1557
1558		container = document.createElement("div");
1559		container.style.cssText = paddingMarginBorderVisibility + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px";
1560		body.insertBefore( container, body.firstChild );
1561
1562		// Construct the test element
1563		div = document.createElement("div");
1564		container.appendChild( div );
1565
1566		// Check if table cells still have offsetWidth/Height when they are set
1567		// to display:none and there are still other visible table cells in a
1568		// table row; if so, offsetWidth/Height are not reliable for use when
1569		// determining if an element has been hidden directly using
1570		// display:none (it is still safe to use offsets if a parent element is
1571		// hidden; don safety goggles and see bug #4512 for more information).
1572		// (only IE 8 fails this test)
1573		div.innerHTML = "<table><tr><td style='" + paddingMarginBorder + "0;display:none'></td><td>t</td></tr></table>";
1574		tds = div.getElementsByTagName( "td" );
1575		isSupported = ( tds[ 0 ].offsetHeight === 0 );
1576
1577		tds[ 0 ].style.display = "";
1578		tds[ 1 ].style.display = "none";
1579
1580		// Check if empty table cells still have offsetWidth/Height
1581		// (IE <= 8 fail this test)
1582		support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1583
1584		// Check if div with explicit width and no margin-right incorrectly
1585		// gets computed margin-right based on width of container. For more
1586		// info see bug #3333
1587		// Fails in WebKit before Feb 2011 nightlies
1588		// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1589		if ( window.getComputedStyle ) {
1590			div.innerHTML = "";
1591			marginDiv = document.createElement( "div" );
1592			marginDiv.style.width = "0";
1593			marginDiv.style.marginRight = "0";
1594			div.style.width = "2px";
1595			div.appendChild( marginDiv );
1596			support.reliableMarginRight =
1597				( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
1598		}
1599
1600		if ( typeof div.style.zoom !== "undefined" ) {
1601			// Check if natively block-level elements act like inline-block
1602			// elements when setting their display to 'inline' and giving
1603			// them layout
1604			// (IE < 8 does this)
1605			div.innerHTML = "";
1606			div.style.width = div.style.padding = "1px";
1607			div.style.border = 0;
1608			div.style.overflow = "hidden";
1609			div.style.display = "inline";
1610			div.style.zoom = 1;
1611			support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
1612
1613			// Check if elements with layout shrink-wrap their children
1614			// (IE 6 does this)
1615			div.style.display = "block";
1616			div.style.overflow = "visible";
1617			div.innerHTML = "<div style='width:5px;'></div>";
1618			support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
1619		}
1620
1621		div.style.cssText = positionTopLeftWidthHeight + paddingMarginBorderVisibility;
1622		div.innerHTML = html;
1623
1624		outer = div.firstChild;
1625		inner = outer.firstChild;
1626		td = outer.nextSibling.firstChild.firstChild;
1627
1628		offsetSupport = {
1629			doesNotAddBorder: ( inner.offsetTop !== 5 ),
1630			doesAddBorderForTableAndCells: ( td.offsetTop === 5 )
1631		};
1632
1633		inner.style.position = "fixed";
1634		inner.style.top = "20px";
1635
1636		// safari subtracts parent border width here which is 5px
1637		offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 );
1638		inner.style.position = inner.style.top = "";
1639
1640		outer.style.overflow = "hidden";
1641		outer.style.position = "relative";
1642
1643		offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 );
1644		offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop );
1645
1646		if ( window.getComputedStyle ) {
1647			div.style.marginTop = "1%";
1648			support.pixelMargin = ( window.getComputedStyle( div, null ) || { marginTop: 0 } ).marginTop !== "1%";
1649		}
1650
1651		if ( typeof container.style.zoom !== "undefined" ) {
1652			container.style.zoom = 1;
1653		}
1654
1655		body.removeChild( container );
1656		marginDiv = div = container = null;
1657
1658		jQuery.extend( support, offsetSupport );
1659	});
1660
1661	return support;
1662})();
1663
1664
1665
1666
1667var rbrace = /^(?:\{.*\}|\[.*\])$/,
1668	rmultiDash = /([A-Z])/g;
1669
1670jQuery.extend({
1671	cache: {},
1672
1673	// Please use with caution
1674	uuid: 0,
1675
1676	// Unique for each copy of jQuery on the page
1677	// Non-digits removed to match rinlinejQuery
1678	expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1679
1680	// The following elements throw uncatchable exceptions if you
1681	// attempt to add expando properties to them.
1682	noData: {
1683		"embed": true,
1684		// Ban all objects except for Flash (which handle expandos)
1685		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1686		"applet": true
1687	},
1688
1689	hasData: function( elem ) {
1690		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1691		return !!elem && !isEmptyDataObject( elem );
1692	},
1693
1694	data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1695		if ( !jQuery.acceptData( elem ) ) {
1696			return;
1697		}
1698
1699		var privateCache, thisCache, ret,
1700			internalKey = jQuery.expando,
1701			getByName = typeof name === "string",
1702
1703			// We have to handle DOM nodes and JS objects differently because IE6-7
1704			// can't GC object references properly across the DOM-JS boundary
1705			isNode = elem.nodeType,
1706
1707			// Only DOM nodes need the global jQuery cache; JS object data is
1708			// attached directly to the object so GC can occur automatically
1709			cache = isNode ? jQuery.cache : elem,
1710
1711			// Only defining an ID for JS objects if its cache already exists allows
1712			// the code to shortcut on the same path as a DOM node with no cache
1713			id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey,
1714			isEvents = name === "events";
1715
1716		// Avoid doing any more work than we need to when trying to get data on an
1717		// object that has no data at all
1718		if ( (!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined ) {
1719			return;
1720		}
1721
1722		if ( !id ) {
1723			// Only DOM nodes need a new unique ID for each element since their data
1724			// ends up in the global cache
1725			if ( isNode ) {
1726				elem[ internalKey ] = id = ++jQuery.uuid;
1727			} else {
1728				id = internalKey;
1729			}
1730		}
1731
1732		if ( !cache[ id ] ) {
1733			cache[ id ] = {};
1734
1735			// Avoids exposing jQuery metadata on plain JS objects when the object
1736			// is serialized using JSON.stringify
1737			if ( !isNode ) {
1738				cache[ id ].toJSON = jQuery.noop;
1739			}
1740		}
1741

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

1928						if ( name.indexOf( "data-" ) === 0 ) {
1929							name = jQuery.camelCase( name.substring(5) );
1930
1931							dataAttr( elem, name, data[ name ] );
1932						}
1933					}
1934					jQuery._data( elem, "parsedAttrs", true );
1935				}
1936			}
1937
1938			return data;
1939		}
1940
1941		// Sets multiple values
1942		if ( typeof key === "object" ) {
1943			return this.each(function() {
1944				jQuery.data( this, key );
1945			});
1946		}
1947
1948		parts = key.split( ".", 2 );
1949		parts[1] = parts[1] ? "." + parts[1] : "";
1950		part = parts[1] + "!";
1951
1952		return jQuery.access( this, function( value ) {
1953
1954			if ( value === undefined ) {
1955				data = this.triggerHandler( "getData" + part, [ parts[0] ] );
1956
1957				// Try to fetch any internally stored data first
1958				if ( data === undefined && elem ) {
1959					data = jQuery.data( elem, key );
1960					data = dataAttr( elem, key, data );
1961				}
1962
1963				return data === undefined && parts[1] ?
1964					this.data( parts[0] ) :
1965					data;
1966			}
1967
1968			parts[1] = value;
1969			this.each(function() {
1970				var self = jQuery( this );
1971
1972				self.triggerHandler( "setData" + part, parts );
1973				jQuery.data( this, key, value );
1974				self.triggerHandler( "changeData" + part, parts );
1975			});
1976		}, null, value, arguments.length > 1, null, false );
1977	},
1978
1979	removeData: function( key ) {
1980		return this.each(function() {
1981			jQuery.removeData( this, key );
1982		});
1983	}
1984});
1985
1986function dataAttr( elem, key, data ) {
1987	// If nothing was found internally, try to fetch any
1988	// data from the HTML5 data-* attribute
1989	if ( data === undefined && elem.nodeType === 1 ) {
1990
1991		var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
1992
1993		data = elem.getAttribute( name );
1994
1995		if ( typeof data === "string" ) {
1996			try {
1997				data = data === "true" ? true :
1998				data === "false" ? false :
1999				data === "null" ? null :
2000				jQuery.isNumeric( data ) ? +data :
2001					rbrace.test( data ) ? jQuery.parseJSON( data ) :
2002					data;
2003			} catch( e ) {}
2004
2005			// Make sure we set the data so it isn't changed later
2006			jQuery.data( elem, key, data );
2007
2008		} else {
2009			data = undefined;
2010		}
2011	}
2012
2013	return data;
2014}
2015
2016// checks a cache object for emptiness
2017function isEmptyDataObject( obj ) {
2018	for ( var name in obj ) {
2019
2020		// if the public data object is empty, the private is still empty
2021		if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
2022			continue;
2023		}
2024		if ( name !== "toJSON" ) {
2025			return false;
2026		}
2027	}
2028
2029	return true;
2030}
2031
2032
2033
2034
2035function handleQueueMarkDefer( elem, type, src ) {
2036	var deferDataKey = type + "defer",
2037		queueDataKey = type + "queue",
2038		markDataKey = type + "mark",
2039		defer = jQuery._data( elem, deferDataKey );
2040	if ( defer &&
2041		( src === "queue" || !jQuery._data(elem, queueDataKey) ) &&
2042		( src === "mark" || !jQuery._data(elem, markDataKey) ) ) {
2043		// Give room for hard-coded callbacks to fire first
2044		// and eventually mark/queue something else on the element
2045		setTimeout( function() {
2046			if ( !jQuery._data( elem, queueDataKey ) &&
2047				!jQuery._data( elem, markDataKey ) ) {
2048				jQuery.removeData( elem, deferDataKey, true );
2049				defer.fire();
2050			}
2051		}, 0 );
2052	}
2053}
2054
2055jQuery.extend({
2056
2057	_mark: function( elem, type ) {
2058		if ( elem ) {
2059			type = ( type || "fx" ) + "mark";
2060			jQuery._data( elem, type, (jQuery._data( elem, type ) || 0) + 1 );
2061		}
2062	},
2063
2064	_unmark: function( force, elem, type ) {
2065		if ( force !== true ) {
2066			type = elem;
2067			elem = force;
2068			force = false;
2069		}
2070		if ( elem ) {
2071			type = type || "fx";
2072			var key = type + "mark",
2073				count = force ? 0 : ( (jQuery._data( elem, key ) || 1) - 1 );
2074			if ( count ) {
2075				jQuery._data( elem, key, count );
2076			} else {
2077				jQuery.removeData( elem, key, true );
2078				handleQueueMarkDefer( elem, type, "mark" );
2079			}
2080		}
2081	},
2082
2083	queue: function( elem, type, data ) {
2084		var q;
2085		if ( elem ) {
2086			type = ( type || "fx" ) + "queue";
2087			q = jQuery._data( elem, type );
2088
2089			// Speed up dequeue by getting out quickly if this is just a lookup
2090			if ( data ) {
2091				if ( !q || jQuery.isArray(data) ) {
2092					q = jQuery._data( elem, type, jQuery.makeArray(data) );
2093				} else {
2094					q.push( data );
2095				}
2096			}
2097			return q || [];
2098		}
2099	},
2100
2101	dequeue: function( elem, type ) {
2102		type = type || "fx";
2103
2104		var queue = jQuery.queue( elem, type ),
2105			fn = queue.shift(),
2106			hooks = {};
2107
2108		// If the fx queue is dequeued, always remove the progress sentinel
2109		if ( fn === "inprogress" ) {
2110			fn = queue.shift();
2111		}
2112
2113		if ( fn ) {
2114			// Add a progress sentinel to prevent the fx queue from being
2115			// automatically dequeued
2116			if ( type === "fx" ) {
2117				queue.unshift( "inprogress" );
2118			}
2119
2120			jQuery._data( elem, type + ".run", hooks );
2121			fn.call( elem, function() {
2122				jQuery.dequeue( elem, type );
2123			}, hooks );
2124		}
2125
2126		if ( !queue.length ) {
2127			jQuery.removeData( elem, type + "queue " + type + ".run", true );
2128			handleQueueMarkDefer( elem, type, "queue" );
2129		}
2130	}
2131});
2132
2133jQuery.fn.extend({
2134	queue: function( type, data ) {
2135		var setter = 2;
2136
2137		if ( typeof type !== "string" ) {
2138			data = type;
2139			type = "fx";
2140			setter--;
2141		}
2142
2143		if ( arguments.length < setter ) {
2144			return jQuery.queue( this[0], type );
2145		}
2146
2147		return data === undefined ?

2148			this :
2149			this.each(function() {
2150				var queue = jQuery.queue( this, type, data );
2151
2152				if ( type === "fx" && queue[0] !== "inprogress" ) {
2153					jQuery.dequeue( this, type );
2154				}
2155			});
2156	},
2157	dequeue: function( type ) {
2158		return this.each(function() {
2159			jQuery.dequeue( this, type );
2160		});
2161	},
2162	// Based off of the plugin by Clint Helfers, with permission.
2163	// http://blindsignals.com/index.php/2009/07/jquery-delay/
2164	delay: function( time, type ) {
2165		time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
2166		type = type || "fx";
2167
2168		return this.queue( type, function( next, hooks ) {
2169			var timeout = setTimeout( next, time );
2170			hooks.stop = function() {
2171				clearTimeout( timeout );
2172			};
2173		});
2174	},
2175	clearQueue: function( type ) {
2176		return this.queue( type || "fx", [] );
2177	},
2178	// Get a promise resolved when queues of a certain type
2179	// are emptied (fx is the type by default)
2180	promise: function( type, object ) {
2181		if ( typeof type !== "string" ) {
2182			object = type;
2183			type = undefined;
2184		}
2185		type = type || "fx";
2186		var defer = jQuery.Deferred(),
2187			elements = this,
2188			i = elements.length,
2189			count = 1,
2190			deferDataKey = type + "defer",
2191			queueDataKey = type + "queue",
2192			markDataKey = type + "mark",
2193			tmp;
2194		function resolve() {
2195			if ( !( --count ) ) {
2196				defer.resolveWith( elements, [ elements ] );
2197			}
2198		}
2199		while( i-- ) {
2200			if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
2201					( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
2202						jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
2203					jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) {
2204				count++;
2205				tmp.add( resolve );
2206			}
2207		}
2208		resolve();
2209		return defer.promise( object );
2210	}
2211});
2212
2213
2214
2215
2216var rclass = /[\n\t\r]/g,
2217	rspace = /\s+/,
2218	rreturn = /\r/g,
2219	rtype = /^(?:button|input)$/i,
2220	rfocusable = /^(?:button|input|object|select|textarea)$/i,
2221	rclickable = /^a(?:rea)?$/i,
2222	rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
2223	getSetAttribute = jQuery.support.getSetAttribute,
2224	nodeHook, boolHook, fixSpecified;
2225
2226jQuery.fn.extend({
2227	attr: function( name, value ) {
2228		return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
2229	},
2230
2231	removeAttr: function( name ) {
2232		return this.each(function() {
2233			jQuery.removeAttr( this, name );
2234		});
2235	},
2236
2237	prop: function( name, value ) {
2238		return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
2239	},
2240
2241	removeProp: function( name ) {
2242		name = jQuery.propFix[ name ] || name;
2243		return this.each(function() {
2244			// try/catch handles cases where IE balks (such as removing a property on window)
2245			try {
2246				this[ name ] = undefined;
2247				delete this[ name ];
2248			} catch( e ) {}
2249		});
2250	},
2251
2252	addClass: function( value ) {
2253		var classNames, i, l, elem,
2254			setClass, c, cl;
2255
2256		if ( jQuery.isFunction( value ) ) {
2257			return this.each(function( j ) {
2258				jQuery( this ).addClass( value.call(this, j, this.className) );
2259			});
2260		}
2261
2262		if ( value && typeof value === "string" ) {
2263			classNames = value.split( rspace );
2264
2265			for ( i = 0, l = this.length; i < l; i++ ) {
2266				elem = this[ i ];
2267
2268				if ( elem.nodeType === 1 ) {
2269					if ( !elem.className && classNames.length === 1 ) {
2270						elem.className = value;
2271
2272					} else {
2273						setClass = " " + elem.className + " ";
2274
2275						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2276							if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
2277								setClass += classNames[ c ] + " ";
2278							}
2279						}
2280						elem.className = jQuery.trim( setClass );
2281					}
2282				}
2283			}
2284		}
2285
2286		return this;
2287	},
2288
2289	removeClass: function( value ) {
2290		var classNames, i, l, elem, className, c, cl;
2291
2292		if ( jQuery.isFunction( value ) ) {
2293			return this.each(function( j ) {
2294				jQuery( this ).removeClass( value.call(this, j, this.className) );
2295			});
2296		}
2297
2298		if ( (value && typeof value === "string") || value === undefined ) {
2299			classNames = ( value || "" ).split( rspace );
2300
2301			for ( i = 0, l = this.length; i < l; i++ ) {
2302				elem = this[ i ];
2303
2304				if ( elem.nodeType === 1 && elem.className ) {
2305					if ( value ) {
2306						className = (" " + elem.className + " ").replace( rclass, " " );
2307						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
2308							className = className.replace(" " + classNames[ c ] + " ", " ");
2309						}
2310						elem.className = jQuery.trim( className );
2311
2312					} else {
2313						elem.className = "";
2314					}
2315				}
2316			}
2317		}
2318
2319		return this;
2320	},
2321
2322	toggleClass: function( value, stateVal ) {
2323		var type = typeof value,
2324			isBool = typeof stateVal === "boolean";
2325
2326		if ( jQuery.isFunction( value ) ) {
2327			return this.each(function( i ) {
2328				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
2329			});
2330		}
2331
2332		return this.each(function() {
2333			if ( type === "string" ) {
2334				// toggle individual class names
2335				var className,
2336					i = 0,
2337					self = jQuery( this ),
2338					state = stateVal,
2339					classNames = value.split( rspace );
2340
2341				while ( (className = classNames[ i++ ]) ) {
2342					// check each className given, space seperated list
2343					state = isBool ? state : !self.hasClass( className );
2344					self[ state ? "addClass" : "removeClass" ]( className );
2345				}
2346
2347			} else if ( type === "undefined" || type === "boolean" ) {
2348				if ( this.className ) {
2349					// store className if set
2350					jQuery._data( this, "__className__", this.className );
2351				}
2352
2353				// toggle whole className
2354				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2355			}
2356		});
2357	},
2358
2359	hasClass: function( selector ) {
2360		var className = " " + selector + " ",
2361			i = 0,
2362			l = this.length;
2363		for ( ; i < l; i++ ) {
2364			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2365				return true;
2366			}
2367		}
2368
2369		return false;

2370	},
2371
2372	val: function( value ) {
2373		var hooks, ret, isFunction,
2374			elem = this[0];
2375
2376		if ( !arguments.length ) {
2377			if ( elem ) {
2378				hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
2379
2380				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2381					return ret;
2382				}
2383
2384				ret = elem.value;
2385
2386				return typeof ret === "string" ?
2387					// handle most common string cases
2388					ret.replace(rreturn, "") :
2389					// handle cases where value is null/undef or number
2390					ret == null ? "" : ret;
2391			}
2392
2393			return;
2394		}
2395
2396		isFunction = jQuery.isFunction( value );
2397
2398		return this.each(function( i ) {
2399			var self = jQuery(this), val;
2400
2401			if ( this.nodeType !== 1 ) {
2402				return;
2403			}
2404
2405			if ( isFunction ) {
2406				val = value.call( this, i, self.val() );
2407			} else {
2408				val = value;
2409			}
2410
2411			// Treat null/undefined as ""; convert numbers to string
2412			if ( val == null ) {
2413				val = "";
2414			} else if ( typeof val === "number" ) {
2415				val += "";
2416			} else if ( jQuery.isArray( val ) ) {
2417				val = jQuery.map(val, function ( value ) {
2418					return value == null ? "" : value + "";
2419				});
2420			}
2421
2422			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
2423
2424			// If set returns undefined, fall back to normal setting
2425			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
2426				this.value = val;
2427			}
2428		});
2429	}
2430});
2431
2432jQuery.extend({
2433	valHooks: {
2434		option: {
2435			get: function( elem ) {
2436				// attributes.value is undefined in Blackberry 4.7 but
2437				// uses .value. See #6932
2438				var val = elem.attributes.value;
2439				return !val || val.specified ? elem.value : elem.text;
2440			}
2441		},
2442		select: {
2443			get: function( elem ) {
2444				var value, i, max, option,
2445					index = elem.selectedIndex,
2446					values = [],
2447					options = elem.options,
2448					one = elem.type === "select-one";
2449
2450				// Nothing was selected
2451				if ( index < 0 ) {
2452					return null;
2453				}
2454
2455				// Loop through all the selected options
2456				i = one ? index : 0;
2457				max = one ? index + 1 : options.length;
2458				for ( ; i < max; i++ ) {
2459					option = options[ i ];
2460
2461					// Don't return options that are disabled or in a disabled optgroup
2462					if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2463							(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
2464
2465						// Get the specific value for the option
2466						value = jQuery( option ).val();
2467
2468						// We don't need an array for one selects
2469						if ( one ) {
2470							return value;
2471						}
2472
2473						// Multi-Selects return an array
2474						values.push( value );
2475					}
2476				}
2477
2478				// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2479				if ( one && !values.length && options.length ) {
2480					return jQuery( options[ index ] ).val();
2481				}
2482
2483				return values;
2484			},
2485
2486			set: function( elem, value ) {
2487				var values = jQuery.makeArray( value );
2488
2489				jQuery(elem).find("option").each(function() {
2490					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2491				});
2492
2493				if ( !values.length ) {
2494					elem.selectedIndex = -1;
2495				}
2496				return values;
2497			}
2498		}
2499	},
2500
2501	attrFn: {
2502		val: true,
2503		css: true,
2504		html: true,
2505		text: true,
2506		data: true,
2507		width: true,
2508		height: true,
2509		offset: true
2510	},
2511
2512	attr: function( elem, name, value, pass ) {
2513		var ret, hooks, notxml,
2514			nType = elem.nodeType;
2515
2516		// don't get/set attributes on text, comment and attribute nodes
2517		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2518			return;
2519		}
2520
2521		if ( pass && name in jQuery.attrFn ) {
2522			return jQuery( elem )[ name ]( value );
2523		}
2524
2525		// Fallback to prop when attributes are not supported
2526		if ( typeof elem.getAttribute === "undefined" ) {
2527			return jQuery.prop( elem, name, value );
2528		}
2529
2530		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2531
2532		// All attributes are lowercase
2533		// Grab necessary hook if one is defined
2534		if ( notxml ) {
2535			name = name.toLowerCase();
2536			hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
2537		}
2538
2539		if ( value !== undefined ) {
2540
2541			if ( value === null ) {
2542				jQuery.removeAttr( elem, name );
2543				return;
2544
2545			} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2546				return ret;
2547
2548			} else {
2549				elem.setAttribute( name, "" + value );
2550				return value;
2551			}
2552
2553		} else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
2554			return ret;
2555
2556		} else {
2557
2558			ret = elem.getAttribute( name );
2559
2560			// Non-existent attributes return null, we normalize to undefined
2561			return ret === null ?
2562				undefined :
2563				ret;
2564		}
2565	},
2566
2567	removeAttr: function( elem, value ) {
2568		var propName, attrNames, name, l, isBool,
2569			i = 0;
2570
2571		if ( value && elem.nodeType === 1 ) {
2572			attrNames = value.toLowerCase().split( rspace );
2573			l = attrNames.length;
2574
2575			for ( ; i < l; i++ ) {
2576				name = attrNames[ i ];
2577

2578				if ( name ) {
2579					propName = jQuery.propFix[ name ] || name;
2580					isBool = rboolean.test( name );
2581
2582					// See #9699 for explanation of this approach (setting first, then removal)
2583					// Do not do this for boolean attributes (see #10870)
2584					if ( !isBool ) {
2585						jQuery.attr( elem, name, "" );
2586					}
2587					elem.removeAttribute( getSetAttribute ? name : propName );
2588
2589					// Set corresponding property to false for boolean attributes
2590					if ( isBool && propName in elem ) {
2591						elem[ propName ] = false;
2592					}
2593				}
2594			}
2595		}
2596	},
2597
2598	attrHooks: {
2599		type: {
2600			set: function( elem, value ) {
2601				// We can't allow the type property to be changed (since it causes problems in IE)
2602				if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
2603					jQuery.error( "type property can't be changed" );
2604				} else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2605					// Setting the type on a radio button after the value resets the value in IE6-9
2606					// Reset value to it's default in case type is set after value
2607					// This is for element creation
2608					var val = elem.value;
2609					elem.setAttribute( "type", value );
2610					if ( val ) {
2611						elem.value = val;
2612					}
2613					return value;
2614				}
2615			}
2616		},
2617		// Use the value property for back compat
2618		// Use the nodeHook for button elements in IE6/7 (#1954)
2619		value: {
2620			get: function( elem, name ) {
2621				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2622					return nodeHook.get( elem, name );
2623				}
2624				return name in elem ?
2625					elem.value :
2626					null;
2627			},
2628			set: function( elem, value, name ) {
2629				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
2630					return nodeHook.set( elem, value, name );
2631				}
2632				// Does not return so that setAttribute is also used
2633				elem.value = value;
2634			}
2635		}
2636	},
2637
2638	propFix: {
2639		tabindex: "tabIndex",
2640		readonly: "readOnly",
2641		"for": "htmlFor",
2642		"class": "className",
2643		maxlength: "maxLength",
2644		cellspacing: "cellSpacing",
2645		cellpadding: "cellPadding",
2646		rowspan: "rowSpan",
2647		colspan: "colSpan",
2648		usemap: "useMap",
2649		frameborder: "frameBorder",
2650		contenteditable: "contentEditable"
2651	},
2652
2653	prop: function( elem, name, value ) {
2654		var ret, hooks, notxml,
2655			nType = elem.nodeType;
2656
2657		// don't get/set properties on text, comment and attribute nodes
2658		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2659			return;
2660		}
2661
2662		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2663
2664		if ( notxml ) {
2665			// Fix name and attach hooks
2666			name = jQuery.propFix[ name ] || name;
2667			hooks = jQuery.propHooks[ name ];
2668		}
2669
2670		if ( value !== undefined ) {
2671			if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2672				return ret;
2673
2674			} else {
2675				return ( elem[ name ] = value );
2676			}
2677
2678		} else {
2679			if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
2680				return ret;
2681
2682			} else {
2683				return elem[ name ];
2684			}
2685		}
2686	},
2687
2688	propHooks: {
2689		tabIndex: {
2690			get: function( elem ) {
2691				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2692				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2693				var attributeNode = elem.getAttributeNode("tabindex");
2694
2695				return attributeNode && attributeNode.specified ?
2696					parseInt( attributeNode.value, 10 ) :
2697					rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
2698						0 :
2699						undefined;
2700			}
2701		}
2702	}
2703});
2704
2705// Add the tabIndex propHook to attrHooks for back-compat (different case is intentional)
2706jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex;
2707
2708// Hook for boolean attributes
2709boolHook = {
2710	get: function( elem, name ) {
2711		// Align boolean attributes with corresponding properties
2712		// Fall back to attribute presence where some booleans are not supported
2713		var attrNode,
2714			property = jQuery.prop( elem, name );
2715		return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
2716			name.toLowerCase() :
2717			undefined;
2718	},
2719	set: function( elem, value, name ) {
2720		var propName;
2721		if ( value === false ) {
2722			// Remove boolean attributes when set to false
2723			jQuery.removeAttr( elem, name );
2724		} else {
2725			// value is true since we know at this point it's type boolean and not false
2726			// Set boolean attributes to the same name and set the DOM property
2727			propName = jQuery.propFix[ name ] || name;
2728			if ( propName in elem ) {
2729				// Only set the IDL specifically if it already exists on the element
2730				elem[ propName ] = true;
2731			}
2732
2733			elem.setAttribute( name, name.toLowerCase() );
2734		}
2735		return name;
2736	}
2737};
2738
2739// IE6/7 do not support getting/setting some attributes with get/setAttribute
2740if ( !getSetAttribute ) {
2741
2742	fixSpecified = {
2743		name: true,
2744		id: true,
2745		coords: true
2746	};
2747
2748	// Use this for any attribute in IE6/7
2749	// This fixes almost every IE6/7 issue
2750	nodeHook = jQuery.valHooks.button = {
2751		get: function( elem, name ) {
2752			var ret;
2753			ret = elem.getAttributeNode( name );
2754			return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ?
2755				ret.nodeValue :
2756				undefined;
2757		},
2758		set: function( elem, value, name ) {
2759			// Set the existing or create a new attribute node
2760			var ret = elem.getAttributeNode( name );
2761			if ( !ret ) {
2762				ret = document.createAttribute( name );
2763				elem.setAttributeNode( ret );
2764			}
2765			return ( ret.nodeValue = value + "" );
2766		}
2767	};
2768
2769	// Apply the nodeHook to tabindex
2770	jQuery.attrHooks.tabindex.set = nodeHook.set;
2771
2772	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
2773	// This is for removals
2774	jQuery.each([ "width", "height" ], function( i, name ) {
2775		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {