https://www.milifestylemarketing.com/App_JavaScript/jquery-1.4.1.js

1/*!
2 * jQuery JavaScript Library v1.4.1
3 * http://jquery.com/
4 *
5 * Copyright 2010, John Resig
6 *
7 * Includes Sizzle.js
8 * http://sizzlejs.com/
9 * Copyright 2010, The Dojo Foundation
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining
12 * a copy of this software and associated documentation files (the
13 * "Software"), to deal in the Software without restriction, including
14 * without limitation the rights to use, copy, modify, merge, publish,
15 * distribute, sublicense, and/or sell copies of the Software, and to
16 * permit persons to whom the Software is furnished to do so, subject to
17 * the following conditions:
18 * 
19 * The above copyright notice and this permission notice shall be
20 * included in all copies or substantial portions of the Software.
21 * 
22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
26 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 * Date: Mon Jan 25 19:43:33 2010 -0500
30 */
31(function( window, undefined ) {
32
33// Define a local copy of jQuery
34var jQuery = function( selector, context ) {
35		// The jQuery object is actually just the init constructor 'enhanced'
36		return new jQuery.fn.init( selector, context );
37	},
38
39	// Map over jQuery in case of overwrite
40	_jQuery = window.jQuery,
41
42	// Map over the $ in case of overwrite
43	_$ = window.$,
44
45	// Use the correct document accordingly with window argument (sandbox)
46	document = window.document,
47
48	// A central reference to the root jQuery(document)
49	rootjQuery,
50
51	// A simple way to check for HTML strings or ID strings
52	// (both of which we optimize for)
53	quickExpr = /^[^<]*(<[\w\W]+>)[^>]*$|^#([\w-]+)$/,
54
55	// Is it a simple selector
56	isSimple = /^.[^:#\[\.,]*$/,
57
58	// Check if a string has a non-whitespace character in it
59	rnotwhite = /\S/,
60
61	// Used for trimming whitespace
62	rtrim = /^(\s|\u00A0)+|(\s|\u00A0)+$/g,
63
64	// Match a standalone tag
65	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
66
67	// Keep a UserAgent string for use with jQuery.browser
68	userAgent = navigator.userAgent,
69
70	// For matching the engine and version of the browser
71	browserMatch,
72	
73	// Has the ready events already been bound?
74	readyBound = false,
75	
76	// The functions to execute on DOM ready
77	readyList = [],
78
79	// The ready event handler
80	DOMContentLoaded,
81
82	// Save a reference to some core methods
83	toString = Object.prototype.toString,
84	hasOwnProperty = Object.prototype.hasOwnProperty,
85	push = Array.prototype.push,
86	slice = Array.prototype.slice,
87	indexOf = Array.prototype.indexOf;
88
89jQuery.fn = jQuery.prototype = {
90	init: function( selector, context ) {
91		var match, elem, ret, doc;
92
93		// Handle $(""), $(null), or $(undefined)
94		if ( !selector ) {
95			return this;
96		}
97
98		// Handle $(DOMElement)
99		if ( selector.nodeType ) {
100			this.context = this[0] = selector;
101			this.length = 1;
102			return this;
103		}
104
105		// Handle HTML strings
106		if ( typeof selector === "string" ) {
107			// Are we dealing with HTML string or an ID?
108			match = quickExpr.exec( selector );
109
110			// Verify a match, and that no context was specified for #id
111			if ( match && (match[1] || !context) ) {
112
113				// HANDLE: $(html) -> $(array)
114				if ( match[1] ) {
115					doc = (context ? context.ownerDocument || context : document);
116
117					// If a single string is passed in and it's a single tag
118					// just do a createElement and skip the rest
119					ret = rsingleTag.exec( selector );
120
121					if ( ret ) {
122						if ( jQuery.isPlainObject( context ) ) {
123							selector = [ document.createElement( ret[1] ) ];
124							jQuery.fn.attr.call( selector, context, true );
125
126						} else {
127							selector = [ doc.createElement( ret[1] ) ];
128						}
129
130					} else {
131						ret = buildFragment( [ match[1] ], [ doc ] );
132						selector = (ret.cacheable ? ret.fragment.cloneNode(true) : ret.fragment).childNodes;
133					}
134
135				// HANDLE: $("#id")
136				} else {
137					elem = document.getElementById( match[2] );
138
139					if ( elem ) {
140						// Handle the case where IE and Opera return items
141						// by name instead of ID
142						if ( elem.id !== match[2] ) {
143							return rootjQuery.find( selector );
144						}
145
146						// Otherwise, we inject the element directly into the jQuery object
147						this.length = 1;
148						this[0] = elem;
149					}
150
151					this.context = document;
152					this.selector = selector;
153					return this;
154				}
155
156			// HANDLE: $("TAG")
157			} else if ( !context && /^\w+$/.test( selector ) ) {
158				this.selector = selector;
159				this.context = document;
160				selector = document.getElementsByTagName( selector );
161
162			// HANDLE: $(expr, $(...))
163			} else if ( !context || context.jquery ) {
164				return (context || rootjQuery).find( selector );
165
166			// HANDLE: $(expr, context)
167			// (which is just equivalent to: $(context).find(expr)
168			} else {
169				return jQuery( context ).find( selector );
170			}
171
172		// HANDLE: $(function)
173		// Shortcut for document ready
174		} else if ( jQuery.isFunction( selector ) ) {
175			return rootjQuery.ready( selector );
176		}
177
178		if (selector.selector !== undefined) {
179			this.selector = selector.selector;
180			this.context = selector.context;
181		}
182
183		return jQuery.isArray( selector ) ?
184			this.setArray( selector ) :
185			jQuery.makeArray( selector, this );
186	},
187
188	// Start with an empty selector
189	selector: "",
190
191	// The current version of jQuery being used
192	jquery: "1.4.1",
193
194	// The default length of a jQuery object is 0
195	length: 0,
196
197	// The number of elements contained in the matched element set
198	size: function() {
199		return this.length;
200	},
201
202	toArray: function() {
203		return slice.call( this, 0 );
204	},
205
206	// Get the Nth element in the matched element set OR
207	// Get the whole matched element set as a clean array
208	get: function( num ) {
209		return num == null ?
210
211			// Return a 'clean' array
212			this.toArray() :
213
214			// Return just the object
215			( num < 0 ? this.slice(num)[ 0 ] : this[ num ] );
216	},
217
218	// Take an array of elements and push it onto the stack
219	// (returning the new matched element set)
220	pushStack: function( elems, name, selector ) {
221		// Build a new jQuery matched element set
222		var ret = jQuery( elems || null );
223
224		// Add the old object onto the stack (as a reference)
225		ret.prevObject = this;
226
227		ret.context = this.context;
228
229		if ( name === "find" ) {
230			ret.selector = this.selector + (this.selector ? " " : "") + selector;
231		} else if ( name ) {
232			ret.selector = this.selector + "." + name + "(" + selector + ")";
233		}
234
235		// Return the newly-formed element set
236		return ret;
237	},
238
239	// Force the current matched set of elements to become
240	// the specified array of elements (destroying the stack in the process)
241	// You should use pushStack() in order to do this, but maintain the stack
242	setArray: function( elems ) {
243		// Resetting the length to 0, then using the native Array push
244		// is a super-fast way to populate an object with array-like properties
245		this.length = 0;
246		push.apply( this, elems );
247
248		return this;
249	},
250
251	// Execute a callback for every element in the matched set.
252	// (You can seed the arguments with an array of args, but this is
253	// only used internally.)
254	each: function( callback, args ) {
255		return jQuery.each( this, callback, args );
256	},
257	
258	ready: function( fn ) {
259		// Attach the listeners
260		jQuery.bindReady();
261
262		// If the DOM is already ready
263		if ( jQuery.isReady ) {
264			// Execute the function immediately
265			fn.call( document, jQuery );
266
267		// Otherwise, remember the function for later
268		} else if ( readyList ) {
269			// Add the function to the wait list
270			readyList.push( fn );
271		}
272
273		return this;
274	},
275	
276	eq: function( i ) {
277		return i === -1 ?
278			this.slice( i ) :
279			this.slice( i, +i + 1 );
280	},
281
282	first: function() {
283		return this.eq( 0 );
284	},
285
286	last: function() {
287		return this.eq( -1 );
288	},
289
290	slice: function() {
291		return this.pushStack( slice.apply( this, arguments ),
292			"slice", slice.call(arguments).join(",") );
293	},
294
295	map: function( callback ) {
296		return this.pushStack( jQuery.map(this, function( elem, i ) {
297			return callback.call( elem, i, elem );
298		}));
299	},
300	
301	end: function() {
302		return this.prevObject || jQuery(null);
303	},
304
305	// For internal use only.
306	// Behaves like an Array's method, not like a jQuery method.
307	push: push,
308	sort: [].sort,
309	splice: [].splice
310};
311
312// Give the init function the jQuery prototype for later instantiation
313jQuery.fn.init.prototype = jQuery.fn;
314
315jQuery.extend = jQuery.fn.extend = function() {
316	// copy reference to target object
317	var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options, name, src, copy;
318
319	// Handle a deep copy situation
320	if ( typeof target === "boolean" ) {
321		deep = target;
322		target = arguments[1] || {};
323		// skip the boolean and the target
324		i = 2;
325	}
326
327	// Handle case when target is a string or something (possible in deep copy)
328	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
329		target = {};
330	}
331
332	// extend jQuery itself if only one argument is passed
333	if ( length === i ) {
334		target = this;
335		--i;
336	}
337
338	for ( ; i < length; i++ ) {
339		// Only deal with non-null/undefined values
340		if ( (options = arguments[ i ]) != null ) {
341			// Extend the base object
342			for ( name in options ) {
343				src = target[ name ];
344				copy = options[ name ];
345
346				// Prevent never-ending loop
347				if ( target === copy ) {
348					continue;
349				}
350
351				// Recurse if we're merging object literal values or arrays
352				if ( deep && copy && ( jQuery.isPlainObject(copy) || jQuery.isArray(copy) ) ) {
353					var clone = src && ( jQuery.isPlainObject(src) || jQuery.isArray(src) ) ? src
354						: jQuery.isArray(copy) ? [] : {};
355
356					// Never move original objects, clone them
357					target[ name ] = jQuery.extend( deep, clone, copy );
358
359				// Don't bring in undefined values
360				} else if ( copy !== undefined ) {
361					target[ name ] = copy;
362				}
363			}
364		}
365	}
366
367	// Return the modified object
368	return target;
369};
370
371jQuery.extend({
372	noConflict: function( deep ) {
373		window.$ = _$;
374
375		if ( deep ) {
376			window.jQuery = _jQuery;
377		}
378
379		return jQuery;
380	},
381	
382	// Is the DOM ready to be used? Set to true once it occurs.
383	isReady: false,
384	
385	// Handle when the DOM is ready
386	ready: function() {
387		// Make sure that the DOM is not already loaded
388		if ( !jQuery.isReady ) {
389			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
390			if ( !document.body ) {
391				return setTimeout( jQuery.ready, 13 );
392			}
393
394			// Remember that the DOM is ready
395			jQuery.isReady = true;
396
397			// If there are functions bound, to execute
398			if ( readyList ) {
399				// Execute all of them
400				var fn, i = 0;
401				while ( (fn = readyList[ i++ ]) ) {
402					fn.call( document, jQuery );
403				}
404
405				// Reset the list of functions
406				readyList = null;
407			}
408
409			// Trigger any bound ready events
410			if ( jQuery.fn.triggerHandler ) {
411				jQuery( document ).triggerHandler( "ready" );
412			}
413		}
414	},
415	
416	bindReady: function() {
417		if ( readyBound ) {
418			return;
419		}
420
421		readyBound = true;
422
423		// Catch cases where $(document).ready() is called after the
424		// browser event has already occurred.
425		if ( document.readyState === "complete" ) {
426			return jQuery.ready();
427		}
428
429		// Mozilla, Opera and webkit nightlies currently support this event
430		if ( document.addEventListener ) {
431			// Use the handy event callback
432			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
433			
434			// A fallback to window.onload, that will always work
435			window.addEventListener( "load", jQuery.ready, false );
436
437		// If IE event model is used
438		} else if ( document.attachEvent ) {
439			// ensure firing before onload,
440			// maybe late but safe also for iframes
441			document.attachEvent("onreadystatechange", DOMContentLoaded);
442			
443			// A fallback to window.onload, that will always work
444			window.attachEvent( "onload", jQuery.ready );
445
446			// If IE and not a frame
447			// continually check to see if the document is ready
448			var toplevel = false;
449
450			try {
451				toplevel = window.frameElement == null;
452			} catch(e) {}
453
454			if ( document.documentElement.doScroll && toplevel ) {
455				doScrollCheck();
456			}
457		}
458	},
459
460	// See test/unit/core.js for details concerning isFunction.
461	// Since version 1.3, DOM methods and functions like alert
462	// aren't supported. They return false on IE (#2968).
463	isFunction: function( obj ) {
464		return toString.call(obj) === "[object Function]";
465	},
466
467	isArray: function( obj ) {
468		return toString.call(obj) === "[object Array]";
469	},
470
471	isPlainObject: function( obj ) {
472		// Must be an Object.
473		// Because of IE, we also have to check the presence of the constructor property.
474		// Make sure that DOM nodes and window objects don't pass through, as well
475		if ( !obj || toString.call(obj) !== "[object Object]" || obj.nodeType || obj.setInterval ) {
476			return false;
477		}
478		
479		// Not own constructor property must be Object
480		if ( obj.constructor
481			&& !hasOwnProperty.call(obj, "constructor")
482			&& !hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf") ) {
483			return false;
484		}
485		
486		// Own properties are enumerated firstly, so to speed up,
487		// if last one is own, then all properties are own.
488	
489		var key;
490		for ( key in obj ) {}
491		
492		return key === undefined || hasOwnProperty.call( obj, key );
493	},
494
495	isEmptyObject: function( obj ) {
496		for ( var name in obj ) {
497			return false;
498		}
499		return true;
500	},
501	
502	error: function( msg ) {
503		throw msg;
504	},
505	
506	parseJSON: function( data ) {
507		if ( typeof data !== "string" || !data ) {
508			return null;
509		}
510		
511		// Make sure the incoming data is actual JSON
512		// Logic borrowed from http://json.org/json2.js
513		if ( /^[\],:{}\s]*$/.test(data.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, "@")
514			.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]")
515			.replace(/(?:^|:|,)(?:\s*\[)+/g, "")) ) {
516
517			// Try to use the native JSON parser first
518			return window.JSON && window.JSON.parse ?
519				window.JSON.parse( data ) :
520				(new Function("return " + data))();
521
522		} else {
523			jQuery.error( "Invalid JSON: " + data );
524		}
525	},
526
527	noop: function() {},
528
529	// Evalulates a script in a global context
530	globalEval: function( data ) {
531		if ( data && rnotwhite.test(data) ) {
532			// Inspired by code by Andrea Giammarchi
533			// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
534			var head = document.getElementsByTagName("head")[0] || document.documentElement,
535				script = document.createElement("script");
536
537			script.type = "text/javascript";
538
539			if ( jQuery.support.scriptEval ) {
540				script.appendChild( document.createTextNode( data ) );
541			} else {
542				script.text = data;
543			}
544
545			// Use insertBefore instead of appendChild to circumvent an IE6 bug.
546			// This arises when a base node is used (#2709).
547			head.insertBefore( script, head.firstChild );
548			head.removeChild( script );
549		}
550	},
551
552	nodeName: function( elem, name ) {
553		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
554	},
555
556	// args is for internal usage only
557	each: function( object, callback, args ) {
558		var name, i = 0,
559			length = object.length,
560			isObj = length === undefined || jQuery.isFunction(object);
561
562		if ( args ) {
563			if ( isObj ) {
564				for ( name in object ) {
565					if ( callback.apply( object[ name ], args ) === false ) {
566						break;
567					}
568				}
569			} else {
570				for ( ; i < length; ) {
571					if ( callback.apply( object[ i++ ], args ) === false ) {
572						break;
573					}
574				}
575			}
576
577		// A special, fast, case for the most common use of each
578		} else {
579			if ( isObj ) {
580				for ( name in object ) {
581					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
582						break;
583					}
584				}
585			} else {
586				for ( var value = object[0];
587					i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
588			}
589		}
590
591		return object;
592	},
593
594	trim: function( text ) {
595		return (text || "").replace( rtrim, "" );
596	},
597
598	// results is for internal usage only
599	makeArray: function( array, results ) {
600		var ret = results || [];
601
602		if ( array != null ) {
603			// The window, strings (and functions) also have 'length'
604			// The extra typeof function check is to prevent crashes
605			// in Safari 2 (See: #3039)
606			if ( array.length == null || typeof array === "string" || jQuery.isFunction(array) || (typeof array !== "function" && array.setInterval) ) {
607				push.call( ret, array );
608			} else {
609				jQuery.merge( ret, array );
610			}
611		}
612
613		return ret;
614	},
615
616	inArray: function( elem, array ) {
617		if ( array.indexOf ) {
618			return array.indexOf( elem );
619		}
620
621		for ( var i = 0, length = array.length; i < length; i++ ) {
622			if ( array[ i ] === elem ) {
623				return i;
624			}
625		}
626
627		return -1;
628	},
629
630	merge: function( first, second ) {
631		var i = first.length, j = 0;
632
633		if ( typeof second.length === "number" ) {
634			for ( var l = second.length; j < l; j++ ) {
635				first[ i++ ] = second[ j ];
636			}
637		} else {
638			while ( second[j] !== undefined ) {
639				first[ i++ ] = second[ j++ ];
640			}
641		}
642
643		first.length = i;
644
645		return first;
646	},
647
648	grep: function( elems, callback, inv ) {
649		var ret = [];
650
651		// Go through the array, only saving the items
652		// that pass the validator function
653		for ( var i = 0, length = elems.length; i < length; i++ ) {
654			if ( !inv !== !callback( elems[ i ], i ) ) {
655				ret.push( elems[ i ] );
656			}
657		}
658
659		return ret;
660	},
661
662	// arg is for internal usage only
663	map: function( elems, callback, arg ) {
664		var ret = [], value;
665
666		// Go through the array, translating each of the items to their
667		// new value (or values).
668		for ( var i = 0, length = elems.length; i < length; i++ ) {
669			value = callback( elems[ i ], i, arg );
670
671			if ( value != null ) {
672				ret[ ret.length ] = value;
673			}
674		}
675
676		return ret.concat.apply( [], ret );
677	},
678
679	// A global GUID counter for objects
680	guid: 1,
681
682	proxy: function( fn, proxy, thisObject ) {
683		if ( arguments.length === 2 ) {
684			if ( typeof proxy === "string" ) {
685				thisObject = fn;
686				fn = thisObject[ proxy ];
687				proxy = undefined;
688
689			} else if ( proxy && !jQuery.isFunction( proxy ) ) {
690				thisObject = proxy;
691				proxy = undefined;
692			}
693		}
694
695		if ( !proxy && fn ) {
696			proxy = function() {
697				return fn.apply( thisObject || this, arguments );
698			};
699		}
700
701		// Set the guid of unique handler to the same of original handler, so it can be removed
702		if ( fn ) {
703			proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
704		}
705
706		// So proxy can be declared as an argument
707		return proxy;
708	},
709
710	// Use of jQuery.browser is frowned upon.
711	// More details: http://docs.jquery.com/Utilities/jQuery.browser
712	uaMatch: function( ua ) {
713		ua = ua.toLowerCase();
714
715		var match = /(webkit)[ \/]([\w.]+)/.exec( ua ) ||
716			/(opera)(?:.*version)?[ \/]([\w.]+)/.exec( ua ) ||
717			/(msie) ([\w.]+)/.exec( ua ) ||
718			!/compatible/.test( ua ) && /(mozilla)(?:.*? rv:([\w.]+))?/.exec( ua ) ||
719		  	[];
720
721		return { browser: match[1] || "", version: match[2] || "0" };
722	},
723
724	browser: {}
725});
726
727browserMatch = jQuery.uaMatch( userAgent );
728if ( browserMatch.browser ) {
729	jQuery.browser[ browserMatch.browser ] = true;
730	jQuery.browser.version = browserMatch.version;
731}
732
733// Deprecated, use jQuery.browser.webkit instead
734if ( jQuery.browser.webkit ) {
735	jQuery.browser.safari = true;
736}
737
738if ( indexOf ) {
739	jQuery.inArray = function( elem, array ) {
740		return indexOf.call( array, elem );
741	};
742}
743
744// All jQuery objects should point back to these
745rootjQuery = jQuery(document);
746
747// Cleanup functions for the document ready method
748if ( document.addEventListener ) {
749	DOMContentLoaded = function() {
750		document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
751		jQuery.ready();
752	};
753
754} else if ( document.attachEvent ) {
755	DOMContentLoaded = function() {
756		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
757		if ( document.readyState === "complete" ) {
758			document.detachEvent( "onreadystatechange", DOMContentLoaded );
759			jQuery.ready();
760		}
761	};
762}
763
764// The DOM ready check for Internet Explorer
765function doScrollCheck() {
766	if ( jQuery.isReady ) {
767		return;
768	}
769
770	try {
771		// If IE is used, use the trick by Diego Perini
772		// http://javascript.nwbox.com/IEContentLoaded/
773		document.documentElement.doScroll("left");
774	} catch( error ) {
775		setTimeout( doScrollCheck, 1 );
776		return;
777	}
778
779	// and execute any waiting functions
780	jQuery.ready();
781}
782
783function evalScript( i, elem ) {
784	if ( elem.src ) {
785		jQuery.ajax({
786			url: elem.src,
787			async: false,
788			dataType: "script"
789		});
790	} else {
791		jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
792	}
793
794	if ( elem.parentNode ) {
795		elem.parentNode.removeChild( elem );
796	}
797}
798
799// Mutifunctional method to get and set values to a collection
800// The value/s can be optionally by executed if its a function
801function access( elems, key, value, exec, fn, pass ) {
802	var length = elems.length;
803	
804	// Setting many attributes
805	if ( typeof key === "object" ) {
806		for ( var k in key ) {
807			access( elems, k, key[k], exec, fn, value );
808		}
809		return elems;
810	}
811	
812	// Setting one attribute
813	if ( value !== undefined ) {
814		// Optionally, function values get executed if exec is true
815		exec = !pass && exec && jQuery.isFunction(value);
816		
817		for ( var i = 0; i < length; i++ ) {
818			fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
819		}
820		
821		return elems;
822	}
823	
824	// Getting an attribute
825	return length ? fn( elems[0], key ) : null;
826}
827
828function now() {
829	return (new Date).getTime();
830}
831(function() {
832
833	jQuery.support = {};
834
835	var root = document.documentElement,
836		script = document.createElement("script"),
837		div = document.createElement("div"),
838		id = "script" + now();
839
840	div.style.display = "none";
841	div.innerHTML = "   <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
842
843	var all = div.getElementsByTagName("*"),
844		a = div.getElementsByTagName("a")[0];
845
846	// Can't get basic test support
847	if ( !all || !all.length || !a ) {
848		return;
849	}
850
851	jQuery.support = {
852		// IE strips leading whitespace when .innerHTML is used
853		leadingWhitespace: div.firstChild.nodeType === 3,
854
855		// Make sure that tbody elements aren't automatically inserted
856		// IE will insert them into empty tables
857		tbody: !div.getElementsByTagName("tbody").length,
858
859		// Make sure that link elements get serialized correctly by innerHTML
860		// This requires a wrapper element in IE
861		htmlSerialize: !!div.getElementsByTagName("link").length,
862
863		// Get the style information from getAttribute
864		// (IE uses .cssText insted)
865		style: /red/.test( a.getAttribute("style") ),
866
867		// Make sure that URLs aren't manipulated
868		// (IE normalizes it by default)
869		hrefNormalized: a.getAttribute("href") === "/a",
870
871		// Make sure that element opacity exists
872		// (IE uses filter instead)
873		// Use a regex to work around a WebKit issue. See #5145
874		opacity: /^0.55$/.test( a.style.opacity ),
875
876		// Verify style float existence
877		// (IE uses styleFloat instead of cssFloat)
878		cssFloat: !!a.style.cssFloat,
879
880		// Make sure that if no value is specified for a checkbox
881		// that it defaults to "on".
882		// (WebKit defaults to "" instead)
883		checkOn: div.getElementsByTagName("input")[0].value === "on",
884
885		// Make sure that a selected-by-default option has a working selected property.
886		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
887		optSelected: document.createElement("select").appendChild( document.createElement("option") ).selected,
888
889		// Will be defined later
890		checkClone: false,
891		scriptEval: false,
892		noCloneEvent: true,
893		boxModel: null
894	};
895
896	script.type = "text/javascript";
897	try {
898		script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
899	} catch(e) {}
900
901	root.insertBefore( script, root.firstChild );
902
903	// Make sure that the execution of code works by injecting a script
904	// tag with appendChild/createTextNode
905	// (IE doesn't support this, fails, and uses .text instead)
906	if ( window[ id ] ) {
907		jQuery.support.scriptEval = true;
908		delete window[ id ];
909	}
910
911	root.removeChild( script );
912
913	if ( div.attachEvent && div.fireEvent ) {
914		div.attachEvent("onclick", function click() {
915			// Cloning a node shouldn't copy over any
916			// bound event handlers (IE does this)
917			jQuery.support.noCloneEvent = false;
918			div.detachEvent("onclick", click);
919		});
920		div.cloneNode(true).fireEvent("onclick");
921	}
922
923	div = document.createElement("div");
924	div.innerHTML = "<input type='radio' name='radiotest' checked='checked'/>";
925
926	var fragment = document.createDocumentFragment();
927	fragment.appendChild( div.firstChild );
928
929	// WebKit doesn't clone checked state correctly in fragments
930	jQuery.support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
931
932	// Figure out if the W3C box model works as expected
933	// document.body must exist before we can do this
934	jQuery(function() {
935		var div = document.createElement("div");
936		div.style.width = div.style.paddingLeft = "1px";
937
938		document.body.appendChild( div );
939		jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
940		document.body.removeChild( div ).style.display = 'none';
941		div = null;
942	});
943
944	// Technique from Juriy Zaytsev
945	// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
946	var eventSupported = function( eventName ) { 
947		var el = document.createElement("div"); 
948		eventName = "on" + eventName; 
949
950		var isSupported = (eventName in el); 
951		if ( !isSupported ) { 
952			el.setAttribute(eventName, "return;"); 
953			isSupported = typeof el[eventName] === "function"; 
954		} 
955		el = null; 
956
957		return isSupported; 
958	};
959	
960	jQuery.support.submitBubbles = eventSupported("submit");
961	jQuery.support.changeBubbles = eventSupported("change");
962
963	// release memory in IE
964	root = script = div = all = a = null;
965})();
966
967jQuery.props = {
968	"for": "htmlFor",
969	"class": "className",
970	readonly: "readOnly",
971	maxlength: "maxLength",
972	cellspacing: "cellSpacing",
973	rowspan: "rowSpan",
974	colspan: "colSpan",
975	tabindex: "tabIndex",
976	usemap: "useMap",
977	frameborder: "frameBorder"
978};
979var expando = "jQuery" + now(), uuid = 0, windowData = {};
980var emptyObject = {};
981
982jQuery.extend({
983	cache: {},
984	
985	expando:expando,
986
987	// The following elements throw uncatchable exceptions if you
988	// attempt to add expando properties to them.
989	noData: {
990		"embed": true,
991		"object": true,
992		"applet": true
993	},
994
995	data: function( elem, name, data ) {
996		if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
997			return;
998		}
999
1000		elem = elem == window ?
1001			windowData :
1002			elem;
1003
1004		var id = elem[ expando ], cache = jQuery.cache, thisCache;
1005
1006		// Handle the case where there's no name immediately
1007		if ( !name && !id ) {
1008			return null;
1009		}
1010
1011		// Compute a unique ID for the element
1012		if ( !id ) { 
1013			id = ++uuid;
1014		}
1015
1016		// Avoid generating a new cache unless none exists and we
1017		// want to manipulate it.
1018		if ( typeof name === "object" ) {
1019			elem[ expando ] = id;
1020			thisCache = cache[ id ] = jQuery.extend(true, {}, name);
1021		} else if ( cache[ id ] ) {
1022			thisCache = cache[ id ];
1023		} else if ( typeof data === "undefined" ) {
1024			thisCache = emptyObject;
1025		} else {
1026			thisCache = cache[ id ] = {};
1027		}
1028
1029		// Prevent overriding the named cache with undefined values
1030		if ( data !== undefined ) {
1031			elem[ expando ] = id;
1032			thisCache[ name ] = data;
1033		}
1034
1035		return typeof name === "string" ? thisCache[ name ] : thisCache;
1036	},
1037
1038	removeData: function( elem, name ) {
1039		if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
1040			return;
1041		}
1042
1043		elem = elem == window ?
1044			windowData :
1045			elem;
1046
1047		var id = elem[ expando ], cache = jQuery.cache, thisCache = cache[ id ];
1048
1049		// If we want to remove a specific section of the element's data
1050		if ( name ) {
1051			if ( thisCache ) {
1052				// Remove the section of cache data
1053				delete thisCache[ name ];
1054
1055				// If we've removed all the data, remove the element's cache
1056				if ( jQuery.isEmptyObject(thisCache) ) {
1057					jQuery.removeData( elem );
1058				}
1059			}
1060
1061		// Otherwise, we want to remove all of the element's data
1062		} else {
1063			// Clean up the element expando
1064			try {
1065				delete elem[ expando ];
1066			} catch( e ) {
1067				// IE has trouble directly removing the expando
1068				// but it's ok with using removeAttribute
1069				if ( elem.removeAttribute ) {
1070					elem.removeAttribute( expando );
1071				}
1072			}
1073
1074			// Completely remove the data cache
1075			delete cache[ id ];
1076		}
1077	}
1078});
1079
1080jQuery.fn.extend({
1081	data: function( key, value ) {
1082		if ( typeof key === "undefined" && this.length ) {
1083			return jQuery.data( this[0] );
1084
1085		} else if ( typeof key === "object" ) {
1086			return this.each(function() {
1087				jQuery.data( this, key );
1088			});
1089		}
1090
1091		var parts = key.split(".");
1092		parts[1] = parts[1] ? "." + parts[1] : "";
1093
1094		if ( value === undefined ) {
1095			var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1096
1097			if ( data === undefined && this.length ) {
1098				data = jQuery.data( this[0], key );
1099			}
1100			return data === undefined && parts[1] ?
1101				this.data( parts[0] ) :
1102				data;
1103		} else {
1104			return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function() {
1105				jQuery.data( this, key, value );
1106			});
1107		}
1108	},
1109
1110	removeData: function( key ) {
1111		return this.each(function() {
1112			jQuery.removeData( this, key );
1113		});
1114	}
1115});
1116jQuery.extend({
1117	queue: function( elem, type, data ) {
1118		if ( !elem ) {
1119			return;
1120		}
1121
1122		type = (type || "fx") + "queue";
1123		var q = jQuery.data( elem, type );
1124
1125		// Speed up dequeue by getting out quickly if this is just a lookup
1126		if ( !data ) {
1127			return q || [];
1128		}
1129
1130		if ( !q || jQuery.isArray(data) ) {
1131			q = jQuery.data( elem, type, jQuery.makeArray(data) );
1132
1133		} else {
1134			q.push( data );
1135		}
1136
1137		return q;
1138	},
1139
1140	dequeue: function( elem, type ) {
1141		type = type || "fx";
1142
1143		var queue = jQuery.queue( elem, type ), fn = queue.shift();
1144
1145		// If the fx queue is dequeued, always remove the progress sentinel
1146		if ( fn === "inprogress" ) {
1147			fn = queue.shift();
1148		}
1149
1150		if ( fn ) {
1151			// Add a progress sentinel to prevent the fx queue from being
1152			// automatically dequeued
1153			if ( type === "fx" ) {
1154				queue.unshift("inprogress");
1155			}
1156
1157			fn.call(elem, function() {
1158				jQuery.dequeue(elem, type);
1159			});
1160		}
1161	}
1162});
1163
1164jQuery.fn.extend({
1165	queue: function( type, data ) {
1166		if ( typeof type !== "string" ) {
1167			data = type;
1168			type = "fx";
1169		}
1170
1171		if ( data === undefined ) {
1172			return jQuery.queue( this[0], type );
1173		}
1174		return this.each(function( i, elem ) {
1175			var queue = jQuery.queue( this, type, data );
1176
1177			if ( type === "fx" && queue[0] !== "inprogress" ) {
1178				jQuery.dequeue( this, type );
1179			}
1180		});
1181	},
1182	dequeue: function( type ) {
1183		return this.each(function() {
1184			jQuery.dequeue( this, type );
1185		});
1186	},
1187
1188	// Based off of the plugin by Clint Helfers, with permission.
1189	// http://blindsignals.com/index.php/2009/07/jquery-delay/
1190	delay: function( time, type ) {
1191		time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1192		type = type || "fx";
1193
1194		return this.queue( type, function() {
1195			var elem = this;
1196			setTimeout(function() {
1197				jQuery.dequeue( elem, type );
1198			}, time );
1199		});
1200	},
1201
1202	clearQueue: function( type ) {
1203		return this.queue( type || "fx", [] );
1204	}
1205});
1206var rclass = /[\n\t]/g,
1207	rspace = /\s+/,
1208	rreturn = /\r/g,
1209	rspecialurl = /href|src|style/,
1210	rtype = /(button|input)/i,
1211	rfocusable = /(button|input|object|select|textarea)/i,
1212	rclickable = /^(a|area)$/i,
1213	rradiocheck = /radio|checkbox/;
1214
1215jQuery.fn.extend({
1216	attr: function( name, value ) {
1217		return access( this, name, value, true, jQuery.attr );
1218	},
1219
1220	removeAttr: function( name, fn ) {
1221		return this.each(function(){
1222			jQuery.attr( this, name, "" );
1223			if ( this.nodeType === 1 ) {
1224				this.removeAttribute( name );
1225			}
1226		});
1227	},
1228
1229	addClass: function( value ) {
1230		if ( jQuery.isFunction(value) ) {
1231			return this.each(function(i) {
1232				var self = jQuery(this);
1233				self.addClass( value.call(this, i, self.attr("class")) );
1234			});
1235		}
1236
1237		if ( value && typeof value === "string" ) {
1238			var classNames = (value || "").split( rspace );
1239
1240			for ( var i = 0, l = this.length; i < l; i++ ) {
1241				var elem = this[i];
1242
1243				if ( elem.nodeType === 1 ) {
1244					if ( !elem.className ) {
1245						elem.className = value;
1246
1247					} else {
1248						var className = " " + elem.className + " ";
1249						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1250							if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
1251								elem.className += " " + classNames[c];
1252							}
1253						}
1254					}
1255				}
1256			}
1257		}
1258
1259		return this;
1260	},
1261
1262	removeClass: function( value ) {
1263		if ( jQuery.isFunction(value) ) {
1264			return this.each(function(i) {
1265				var self = jQuery(this);
1266				self.removeClass( value.call(this, i, self.attr("class")) );
1267			});
1268		}
1269
1270		if ( (value && typeof value === "string") || value === undefined ) {
1271			var classNames = (value || "").split(rspace);
1272
1273			for ( var i = 0, l = this.length; i < l; i++ ) {
1274				var elem = this[i];
1275
1276				if ( elem.nodeType === 1 && elem.className ) {
1277					if ( value ) {
1278						var className = (" " + elem.className + " ").replace(rclass, " ");
1279						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1280							className = className.replace(" " + classNames[c] + " ", " ");
1281						}
1282						elem.className = className.substring(1, className.length - 1);
1283
1284					} else {
1285						elem.className = "";
1286					}
1287				}
1288			}
1289		}
1290
1291		return this;
1292	},
1293
1294	toggleClass: function( value, stateVal ) {
1295		var type = typeof value, isBool = typeof stateVal === "boolean";
1296
1297		if ( jQuery.isFunction( value ) ) {
1298			return this.each(function(i) {
1299				var self = jQuery(this);
1300				self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
1301			});
1302		}
1303
1304		return this.each(function() {
1305			if ( type === "string" ) {
1306				// toggle individual class names
1307				var className, i = 0, self = jQuery(this),
1308					state = stateVal,
1309					classNames = value.split( rspace );
1310
1311				while ( (className = classNames[ i++ ]) ) {
1312					// check each className given, space seperated list
1313					state = isBool ? state : !self.hasClass( className );
1314					self[ state ? "addClass" : "removeClass" ]( className );
1315				}
1316
1317			} else if ( type === "undefined" || type === "boolean" ) {
1318				if ( this.className ) {
1319					// store className if set
1320					jQuery.data( this, "__className__", this.className );
1321				}
1322
1323				// toggle whole className
1324				this.className = this.className || value === false ? "" : jQuery.data( this, "__className__" ) || "";
1325			}
1326		});
1327	},
1328
1329	hasClass: function( selector ) {
1330		var className = " " + selector + " ";
1331		for ( var i = 0, l = this.length; i < l; i++ ) {
1332			if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
1333				return true;
1334			}
1335		}
1336
1337		return false;
1338	},
1339
1340	val: function( value ) {
1341		if ( value === undefined ) {
1342			var elem = this[0];
1343
1344			if ( elem ) {
1345				if ( jQuery.nodeName( elem, "option" ) ) {
1346					return (elem.attributes.value || {}).specified ? elem.value : elem.text;
1347				}
1348
1349				// We need to handle select boxes special
1350				if ( jQuery.nodeName( elem, "select" ) ) {
1351					var index = elem.selectedIndex,
1352						values = [],
1353						options = elem.options,
1354						one = elem.type === "select-one";
1355
1356					// Nothing was selected
1357					if ( index < 0 ) {
1358						return null;
1359					}
1360
1361					// Loop through all the selected options
1362					for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
1363						var option = options[ i ];
1364
1365						if ( option.selected ) {
1366							// Get the specifc value for the option
1367							value = jQuery(option).val();
1368
1369							// We don't need an array for one selects
1370							if ( one ) {
1371								return value;
1372							}
1373
1374							// Multi-Selects return an array
1375							values.push( value );
1376						}
1377					}
1378
1379					return values;
1380				}
1381
1382				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
1383				if ( rradiocheck.test( elem.type ) && !jQuery.support.checkOn ) {
1384					return elem.getAttribute("value") === null ? "on" : elem.value;
1385				}
1386				
1387
1388				// Everything else, we just grab the value
1389				return (elem.value || "").replace(rreturn, "");
1390
1391			}
1392
1393			return undefined;
1394		}
1395
1396		var isFunction = jQuery.isFunction(value);
1397
1398		return this.each(function(i) {
1399			var self = jQuery(this), val = value;
1400
1401			if ( this.nodeType !== 1 ) {
1402				return;
1403			}
1404
1405			if ( isFunction ) {
1406				val = value.call(this, i, self.val());
1407			}
1408
1409			// Typecast each time if the value is a Function and the appended
1410			// value is therefore different each time.
1411			if ( typeof val === "number" ) {
1412				val += "";
1413			}
1414
1415			if ( jQuery.isArray(val) && rradiocheck.test( this.type ) ) {
1416				this.checked = jQuery.inArray( self.val(), val ) >= 0;
1417
1418			} else if ( jQuery.nodeName( this, "select" ) ) {
1419				var values = jQuery.makeArray(val);
1420
1421				jQuery( "option", this ).each(function() {
1422					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
1423				});
1424
1425				if ( !values.length ) {
1426					this.selectedIndex = -1;
1427				}
1428
1429			} else {
1430				this.value = val;
1431			}
1432		});
1433	}
1434});
1435
1436jQuery.extend({
1437	attrFn: {
1438		val: true,
1439		css: true,
1440		html: true,
1441		text: true,
1442		data: true,
1443		width: true,
1444		height: true,
1445		offset: true
1446	},
1447		
1448	attr: function( elem, name, value, pass ) {
1449		// don't set attributes on text and comment nodes
1450		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
1451			return undefined;
1452		}
1453
1454		if ( pass && name in jQuery.attrFn ) {
1455			return jQuery(elem)[name](value);
1456		}
1457
1458		var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
1459			// Whether we are setting (or getting)
1460			set = value !== undefined;
1461

1798				}
1799			}
1800
1801			// Handle triggering a single element
1802
1803			// don't do events on text and comment nodes
1804			if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
1805				return undefined;
1806			}
1807
1808			// Clean up in case it is reused
1809			event.result = undefined;
1810			event.target = elem;
1811
1812			// Clone the incoming data, if any
1813			data = jQuery.makeArray( data );
1814			data.unshift( event );
1815		}
1816
1817		event.currentTarget = elem;
1818
1819		// Trigger the event, it is assumed that "handle" is a function
1820		var handle = jQuery.data( elem, "handle" );
1821		if ( handle ) {
1822			handle.apply( elem, data );
1823		}
1824
1825		var parent = elem.parentNode || elem.ownerDocument;
1826
1827		// Trigger an inline bound script
1828		try {
1829			if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) {
1830				if ( elem[ "on" + type ] && elem[ "on" + type ].apply( elem, data ) === false ) {
1831					event.result = false;
1832				}
1833			}
1834
1835		// prevent IE from throwing an error for some elements with some event types, see #3533
1836		} catch (e) {}
1837
1838		if ( !event.isPropagationStopped() && parent ) {
1839			jQuery.event.trigger( event, data, parent, true );
1840
1841		} else if ( !event.isDefaultPrevented() ) {
1842			var target = event.target, old,
1843				isClick = jQuery.nodeName(target, "a") && type === "click";
1844
1845			if ( !isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) {
1846				try {
1847					if ( target[ type ] ) {
1848						// Make sure that we don't accidentally re-trigger the onFOO events
1849						old = target[ "on" + type ];
1850
1851						if ( old ) {
1852							target[ "on" + type ] = null;
1853						}
1854
1855						this.triggered = true;
1856						target[ type ]();
1857					}
1858
1859				// prevent IE from throwing an error for some elements with some event types, see #3533
1860				} catch (e) {}
1861
1862				if ( old ) {
1863					target[ "on" + type ] = old;
1864				}
1865
1866				this.triggered = false;
1867			}
1868		}
1869	},
1870
1871	handle: function( event ) {
1872		// returned undefined or false
1873		var all, handlers;
1874
1875		event = arguments[0] = jQuery.event.fix( event || window.event );
1876		event.currentTarget = this;
1877
1878		// Namespaced event handlers
1879		var namespaces = event.type.split(".");
1880		event.type = namespaces.shift();
1881
1882		// Cache this now, all = true means, any handler
1883		all = !namespaces.length && !event.exclusive;
1884
1885		var namespace = new RegExp("(^|\\.)" + namespaces.slice(0).sort().join("\\.(?:.*\\.)?") + "(\\.|$)");
1886
1887		handlers = ( jQuery.data(this, "events") || {} )[ event.type ];
1888
1889		for ( var j in handlers ) {
1890			var handler = handlers[ j ];
1891
1892			// Filter the functions by class
1893			if ( all || namespace.test(handler.type) ) {
1894				// Pass in a reference to the handler function itself
1895				// So that we can later remove it
1896				event.handler = handler;
1897				event.data = handler.data;
1898
1899				var ret = handler.apply( this, arguments );
1900
1901				if ( ret !== undefined ) {
1902					event.result = ret;
1903					if ( ret === false ) {
1904						event.preventDefault();
1905						event.stopPropagation();
1906					}
1907				}
1908
1909				if ( event.isImmediatePropagationStopped() ) {
1910					break;
1911				}
1912
1913			}
1914		}
1915
1916		return event.result;
1917	},
1918
1919	props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
1920
1921	fix: function( event ) {
1922		if ( event[ expando ] ) {
1923			return event;
1924		}
1925
1926		// store a copy of the original event object
1927		// and "clone" to set read-only properties
1928		var originalEvent = event;
1929		event = jQuery.Event( originalEvent );
1930
1931		for ( var i = this.props.length, prop; i; ) {
1932			prop = this.props[ --i ];
1933			event[ prop ] = originalEvent[ prop ];
1934		}
1935
1936		// Fix target property, if necessary
1937		if ( !event.target ) {
1938			event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
1939		}
1940
1941		// check if target is a textnode (safari)
1942		if ( event.target.nodeType === 3 ) {
1943			event.target = event.target.parentNode;
1944		}
1945
1946		// Add relatedTarget, if necessary
1947		if ( !event.relatedTarget && event.fromElement ) {
1948			event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
1949		}
1950
1951		// Calculate pageX/Y if missing and clientX/Y available
1952		if ( event.pageX == null && event.clientX != null ) {
1953			var doc = document.documentElement, body = document.body;
1954			event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
1955			event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
1956		}
1957
1958		// Add which for key events
1959		if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) ) {
1960			event.which = event.charCode || event.keyCode;
1961		}
1962
1963		// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
1964		if ( !event.metaKey && event.ctrlKey ) {
1965			event.metaKey = event.ctrlKey;
1966		}
1967
1968		// Add which for click: 1 === left; 2 === middle; 3 === right
1969		// Note: button is not normalized, so don't use it
1970		if ( !event.which && event.button !== undefined ) {
1971			event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
1972		}
1973
1974		return event;
1975	},
1976
1977	// Deprecated, use jQuery.guid instead
1978	guid: 1E8,
1979
1980	// Deprecated, use jQuery.proxy instead
1981	proxy: jQuery.proxy,
1982
1983	special: {
1984		ready: {
1985			// Make sure the ready event is setup
1986			setup: jQuery.bindReady,
1987			teardown: jQuery.noop
1988		},
1989
1990		live: {
1991			add: function( proxy, data, namespaces, live ) {
1992				jQuery.extend( proxy, data || {} );
1993
1994				proxy.guid += data.selector + data.live; 
1995				data.liveProxy = proxy;
1996
1997				jQuery.event.add( this, data.live, liveHandler, data ); 
1998				
1999			},
2000
2001			remove: function( namespaces ) {
2002				if ( namespaces.length ) {
2003					var remove = 0, name = new RegExp("(^|\\.)" + namespaces[0] + "(\\.|$)");
2004
2005					jQuery.each( (jQuery.data(this, "events").live || {}), function() {
2006						if ( name.test(this.type) ) {
2007							remove++;
2008						}
2009					});
2010
2011					if ( remove < 1 ) {
2012						jQuery.event.remove( this, namespaces[0], liveHandler );
2013					}
2014				}
2015			},
2016			special: {}
2017		},
2018		beforeunload: {
2019			setup: function( data, namespaces, fn ) {
2020				// We only want to do this special case on windows
2021				if ( this.setInterval ) {
2022					this.onbeforeunload = fn;
2023				}
2024
2025				return false;
2026			},
2027			teardown: function( namespaces, fn ) {
2028				if ( this.onbeforeunload === fn ) {
2029					this.onbeforeunload = null;
2030				}
2031			}
2032		}
2033	}
2034};
2035
2036jQuery.Event = function( src ) {
2037	// Allow instantiation without the 'new' keyword
2038	if ( !this.preventDefault ) {
2039		return new jQuery.Event( src );
2040	}
2041
2042	// Event object
2043	if ( src && src.type ) {
2044		this.originalEvent = src;
2045		this.type = src.type;
2046	// Event type
2047	} else {
2048		this.type = src;
2049	}
2050
2051	// timeStamp is buggy for some events on Firefox(#3843)
2052	// So we won't rely on the native value
2053	this.timeStamp = now();
2054
2055	// Mark it as fixed
2056	this[ expando ] = true;
2057};
2058
2059function returnFalse() {
2060	return false;
2061}
2062function returnTrue() {
2063	return true;
2064}
2065
2066// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
2067// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
2068jQuery.Event.prototype = {
2069	preventDefault: function() {
2070		this.isDefaultPrevented = returnTrue;
2071
2072		var e = this.originalEvent;
2073		if ( !e ) {
2074			return;
2075		}
2076		
2077		// if preventDefault exists run it on the original event
2078		if ( e.preventDefault ) {
2079			e.preventDefault();
2080		}
2081		// otherwise set the returnValue property of the original event to false (IE)
2082		e.returnValue = false;
2083	},
2084	stopPropagation: function() {
2085		this.isPropagationStopped = returnTrue;
2086
2087		var e = this.originalEvent;
2088		if ( !e ) {
2089			return;
2090		}
2091		// if stopPropagation exists run it on the original event
2092		if ( e.stopPropagation ) {
2093			e.stopPropagation();
2094		}
2095		// otherwise set the cancelBubble property of the original event to true (IE)
2096		e.cancelBubble = true;
2097	},
2098	stopImmediatePropagation: function() {
2099		this.isImmediatePropagationStopped = returnTrue;
2100		this.stopPropagation();
2101	},
2102	isDefaultPrevented: returnFalse,
2103	isPropagationStopped: returnFalse,
2104	isImmediatePropagationStopped: returnFalse
2105};
2106
2107// Checks if an event happened on an element within another element
2108// Used in jQuery.event.special.mouseenter and mouseleave handlers
2109var withinElement = function( event ) {
2110	// Check if mouse(over|out) are still within the same parent element
2111	var parent = event.relatedTarget;
2112
2113	// Traverse up the tree
2114	while ( parent && parent !== this ) {
2115		// Firefox sometimes assigns relatedTarget a XUL element
2116		// which we cannot access the parentNode property of
2117		try {
2118			parent = parent.parentNode;
2119
2120		// assuming we've left the element since we most likely mousedover a xul element
2121		} catch(e) {
2122			break;
2123		}
2124	}
2125
2126	if ( parent !== this ) {
2127		// set the correct event type
2128		event.type = event.data;
2129
2130		// handle event if we actually just moused on to a non sub-element
2131		jQuery.event.handle.apply( this, arguments );
2132	}
2133
2134},
2135
2136// In case of event delegation, we only need to rename the event.type,
2137// liveHandler will take care of the rest.
2138delegate = function( event ) {
2139	event.type = event.data;
2140	jQuery.event.handle.apply( this, arguments );
2141};
2142
2143// Create mouseenter and mouseleave events
2144jQuery.each({
2145	mouseenter: "mouseover",
2146	mouseleave: "mouseout"
2147}, function( orig, fix ) {
2148	jQuery.event.special[ orig ] = {
2149		setup: function( data ) {
2150			jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
2151		},
2152		teardown: function( data ) {
2153			jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
2154		}
2155	};
2156});
2157
2158// submit delegation
2159if ( !jQuery.support.submitBubbles ) {
2160
2161jQuery.event.special.submit = {
2162	setup: function( data, namespaces, fn ) {
2163		if ( this.nodeName.toLowerCase() !== "form" ) {
2164			jQuery.event.add(this, "click.specialSubmit." + fn.guid, function( e ) {
2165				var elem = e.target, type = elem.type;
2166
2167				if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
2168					return trigger( "submit", this, arguments );
2169				}
2170			});
2171	 
2172			jQuery.event.add(this, "keypress.specialSubmit." + fn.guid, function( e ) {
2173				var elem = e.target, type = elem.type;
2174
2175				if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
2176					return trigger( "submit", this, arguments );
2177				}
2178			});
2179
2180		} else {
2181			return false;
2182		}
2183	},
2184
2185	remove: function( namespaces, fn ) {
2186		jQuery.event.remove( this, "click.specialSubmit" + (fn ? "."+fn.guid : "") );
2187		jQuery.event.remove( this, "keypress.specialSubmit" + (fn ? "."+fn.guid : "") );
2188	}
2189};
2190
2191}
2192
2193// change delegation, happens here so we have bind.
2194if ( !jQuery.support.changeBubbles ) {
2195
2196var formElems = /textarea|input|select/i;
2197
2198function getVal( elem ) {
2199	var type = elem.type, val = elem.value;
2200
2201	if ( type === "radio" || type === "checkbox" ) {
2202		val = elem.checked;
2203
2204	} else if ( type === "select-multiple" ) {
2205		val = elem.selectedIndex > -1 ?
2206			jQuery.map( elem.options, function( elem ) {
2207				return elem.selected;
2208			}).join("-") :
2209			"";
2210
2211	} else if ( elem.nodeName.toLowerCase() === "select" ) {
2212		val = elem.selectedIndex;
2213	}
2214
2215	return val;
2216}
2217
2218function testChange( e ) {
2219		var elem = e.target, data, val;
2220
2221		if ( !formElems.test( elem.nodeName ) || elem.readOnly ) {
2222			return;
2223		}
2224
2225		data = jQuery.data( elem, "_change_data" );
2226		val = getVal(elem);
2227
2228		// the current data will be also retrieved by beforeactivate
2229		if ( e.type !== "focusout" || elem.type !== "radio" ) {
2230			jQuery.data( elem, "_change_data", val );
2231		}
2232		
2233		if ( data === undefined || val === data ) {
2234			return;
2235		}
2236
2237		if ( data != null || val ) {
2238			e.type = "change";
2239			return jQuery.event.trigger( e, arguments[1], elem );
2240		}
2241}
2242
2243jQuery.event.special.change = {
2244	filters: {
2245		focusout: testChange, 
2246
2247		click: function( e ) {
2248			var elem = e.target, type = elem.type;
2249
2250			if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) {
2251				return testChange.call( this, e );
2252			}
2253		},
2254
2255		// Change has to be called before submit
2256		// Keydown will be called before keypress, which is used in submit-event delegation
2257		keydown: function( e ) {
2258			var elem = e.target, type = elem.type;
2259
2260			if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") ||
2261				(e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
2262				type === "select-multiple" ) {
2263				return testChange.call( this, e );
2264			}
2265		},
2266
2267		// Beforeactivate happens also before the previous element is blurred
2268		// with this event you can't trigger a change event, but you can store
2269		// information/focus[in] is not needed anymore
2270		beforeactivate: function( e ) {
2271			var elem = e.target;
2272
2273			if ( elem.nodeName.toLowerCase() === "input" && elem.type === "radio" ) {
2274				jQuery.data( elem, "_change_data", getVal(elem) );
2275			}
2276		}
2277	},
2278	setup: function( data, namespaces, fn ) {
2279		for ( var type in changeFilters ) {
2280			jQuery.event.add( this, type + ".specialChange." + fn.guid, changeFilters[type] );
2281		}
2282
2283		return formElems.test( this.nodeName );
2284	},
2285	remove: function( namespaces, fn ) {
2286		for ( var type in changeFilters ) {
2287			jQuery.event.remove( this, type + ".specialChange" + (fn ? "."+fn.guid : ""), changeFilters[type] );
2288		}
2289
2290		return formElems.test( this.nodeName );
2291	}
2292};
2293
2294var changeFilters = jQuery.event.special.change.filters;
2295
2296}
2297
2298function trigger( type, elem, args ) {
2299	args[0].type = type;
2300	return jQuery.event.handle.apply( elem, args );
2301}
2302
2303// Create "bubbling" focus and blur events
2304if ( document.addEventListener ) {
2305	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
2306		jQuery.event.special[ fix ] = {
2307			setup: function() {
2308				this.addEventListener( orig, handler, true );
2309			}, 
2310			teardown: function() { 
2311				this.removeEventListener( orig, handler, true );
2312			}
2313		};
2314
2315		function handler( e ) { 
2316			e = jQuery.event.fix( e );
2317			e.type = fix;
2318			return jQuery.event.handle.call( this, e );
2319		}
2320	});
2321}
2322
2323jQuery.each(["bind", "one"], function( i, name ) {
2324	jQuery.fn[ name ] = function( type, data, fn ) {
2325		// Handle object literals
2326		if ( typeof type === "object" ) {
2327			for ( var key in type ) {
2328				this[ name ](key, data, type[key], fn);
2329			}
2330			return this;
2331		}
2332		
2333		if ( jQuery.isFunction( data ) ) {
2334			fn = data;
2335			data = undefined;
2336		}
2337
2338		var handler = name === "one" ? jQuery.proxy( fn, function( event ) {
2339			jQuery( this ).unbind( event, handler );
2340			return fn.apply( this, arguments );
2341		}) : fn;
2342
2343		return type === "unload" && name !== "one" ?
2344			this.one( type, data, fn ) :
2345			this.each(function() {
2346				jQuery.event.add( this, type, handler, data );
2347			});
2348	};
2349});
2350
2351jQuery.fn.extend({
2352	unbind: function( type, fn ) {
2353		// Handle object literals
2354		if ( typeof type === "object" && !type.preventDefault ) {
2355			for ( var key in type ) {
2356				this.unbind(key, type[key]);
2357			}
2358			return this;
2359		}
2360
2361		return this.each(function() {
2362			jQuery.event.remove( this, type, fn );
2363		});
2364	},
2365	trigger: function( type, data ) {
2366		return this.each(function() {
2367			jQuery.event.trigger( type, data, this );
2368		});
2369	},
2370
2371	triggerHandler: function( type, data ) {
2372		if ( this[0] ) {
2373			var event = jQuery.Event( type );
2374			event.preventDefault();
2375			event.stopPropagation();
2376			jQuery.event.trigger( event, data, this[0] );
2377			return event.result;
2378		}
2379	},
2380
2381	toggle: function( fn ) {
2382		// Save reference to arguments for access in closure
2383		var args = arguments, i = 1;
2384
2385		// link all the functions, so any of them can unbind this click handler
2386		while ( i < args.length ) {
2387			jQuery.proxy( fn, args[ i++ ] );
2388		}
2389
2390		return this.click( jQuery.proxy( fn, function( event ) {
2391			// Figure out which function to execute
2392			var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
2393			jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
2394
2395			// Make sure that clicks stop
2396			event.preventDefault();
2397
2398			// and execute the function
2399			return args[ lastToggle ].apply( this, arguments ) || false;
2400		}));
2401	},
2402
2403	hover: function( fnOver, fnOut ) {
2404		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
2405	}
2406});
2407
2408jQuery.each(["live", "die"], function( i, name ) {
2409	jQuery.fn[ name ] = function( types, data, fn ) {
2410		var type, i = 0;
2411
2412		if ( jQuery.isFunction( data ) ) {
2413			fn = data;
2414			data = undefined;
2415		}
2416
2417		types = (types || "").split( /\s+/ );
2418
2419		while ( (type = types[ i++ ]) != null ) {
2420			type = type === "focus" ? "focusin" : // focus -->

2556
2557 */
2558(function(){
2559
2560var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
2561	done = 0,
2562	toString = Object.prototype.toString,
2563	hasDuplicate = false,
2564	baseHasDuplicate = true;
2565
2566// Here we check if the JavaScript engine is using some sort of
2567// optimization where it does not always call our comparision
2568// function. If that is the case, discard the hasDuplicate value.
2569//   Thus far that includes Google Chrome.
2570[0, 0].sort(function(){
2571	baseHasDuplicate = false;
2572	return 0;
2573});
2574
2575var Sizzle = function(selector, context, results, seed) {
2576	results = results || [];
2577	var origContext = context = context || document;
2578
2579	if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
2580		return [];
2581	}
2582	
2583	if ( !selector || typeof selector !== "string" ) {
2584		return results;
2585	}
2586
2587	var parts = [], m, set, checkSet, extra, prune = true, contextXML = isXML(context),
2588		soFar = selector;
2589	
2590	// Reset the position of the chunker regexp (start from head)
2591	while ( (chunker.exec(""), m = chunker.exec(soFar)) !== null ) {
2592		soFar = m[3];
2593		
2594		parts.push( m[1] );
2595		
2596		if ( m[2] ) {
2597			extra = m[3];
2598			break;
2599		}
2600	}
2601
2602	if ( parts.length > 1 && origPOS.exec( selector ) ) {
2603		if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
2604			set = posProcess( parts[0] + parts[1], context );
2605		} else {
2606			set = Expr.relative[ parts[0] ] ?
2607				[ context ] :
2608				Sizzle( parts.shift(), context );
2609
2610			while ( parts.length ) {
2611				selector = parts.shift();
2612
2613				if ( Expr.relative[ selector ] ) {
2614					selector += parts.shift();
2615				}
2616				
2617				set = posProcess( selector, set );
2618			}
2619		}
2620	} else {
2621		// Take a shortcut and set the context if the root selector is an ID
2622		// (but not if it'll be faster if the inner selector is an ID)
2623		if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
2624				Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
2625			var ret = Sizzle.find( parts.shift(), context, contextXML );
2626			context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0];
2627		}
2628
2629		if ( context ) {
2630			var ret = seed ?
2631				{ expr: parts.pop(), set: makeArray(seed) } :
2632				Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
2633			set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set;
2634
2635			if ( parts.length > 0 ) {
2636				checkSet = makeArray(set);
2637			} else {
2638				prune = false;
2639			}
2640
2641			while ( parts.length ) {
2642				var cur = parts.pop(), pop = cur;
2643
2644				if ( !Expr.relative[ cur ] ) {
2645					cur = "";
2646				} else {
2647					pop = parts.pop();
2648				}
2649
2650				if ( pop == null ) {
2651					pop = context;
2652				}
2653
2654				Expr.relative[ cur ]( checkSet, pop, contextXML );
2655			}
2656		} else {
2657			checkSet = parts = [];
2658		}
2659	}
2660
2661	if ( !checkSet ) {
2662		checkSet = set;
2663	}
2664
2665	if ( !checkSet ) {
2666		Sizzle.error( cur || selector );
2667	}
2668
2669	if ( toString.call(checkSet) === "[object Array]" ) {
2670		if ( !prune ) {
2671			results.push.apply( results, checkSet );
2672		} else if ( context && context.nodeType === 1 ) {
2673			for ( var i = 0; checkSet[i] != null; i++ ) {
2674				if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
2675					results.push( set[i] );
2676				}
2677			}
2678		} else {
2679			for ( var i = 0; checkSet[i] != null; i++ ) {
2680				if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
2681					results.push( set[i] );
2682				}
2683			}
2684		}
2685	} else {
2686		makeArray( checkSet, results );
2687	}
2688
2689	if ( extra ) {
2690		Sizzle( extra, origContext, results, seed );
2691		Sizzle.uniqueSort( results );
2692	}
2693
2694	return results;
2695};
2696
2697Sizzle.uniqueSort = function(results){
2698	if ( sortOrder ) {
2699		hasDuplicate = baseHasDuplicate;
2700		results.sort(sortOrder);
2701
2702		if ( hasDuplicate ) {
2703			for ( var i = 1; i < results.length; i++ ) {
2704				if ( results[i] === results[i-1] ) {
2705					results.splice(i--, 1);
2706				}
2707			}
2708		}
2709	}
2710
2711	return results;
2712};
2713
2714Sizzle.matches = function(expr, set){
2715	return Sizzle(expr, null, null, set);
2716};
2717
2718Sizzle.find = function(expr, context, isXML){
2719	var set, match;
2720
2721	if ( !expr ) {
2722		return [];
2723	}
2724
2725	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
2726		var type = Expr.order[i], match;
2727		
2728		if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
2729			var left = match[1];
2730			match.splice(1,1);
2731
2732			if ( left.substr( left.length - 1 ) !== "\\" ) {
2733				match[1] = (match[1] || "").replace(/\\/g, "");
2734				set = Expr.find[ type ]( match, context, isXML );
2735				if ( set != null ) {
2736					expr = expr.replace( Expr.match[ type ], "" );
2737					break;
2738				}
2739			}
2740		}
2741	}
2742
2743	if ( !set ) {
2744		set = context.getElementsByTagName("*");
2745	}
2746
2747	return {set: set, expr: expr};
2748};
2749
2750Sizzle.filter = function(expr, set, inplace, not){
2751	var old = expr, result = [], curLoop = set, match, anyFound,
2752		isXMLFilter = set && set[0] && isXML(set[0]);
2753
2754	while ( expr && set.length ) {
2755		for ( var type in Expr.filter ) {
2756			if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
2757				var filter = Expr.filter[ type ], found, item, left = match[1];
2758				anyFound = false;
2759
2760				match.splice(1,1);
2761
2762				if ( left.substr( left.length - 1 ) === "\\" ) {
2763					continue;
2764				}
2765
2766				if ( curLoop === result ) {
2767					result = [];
2768				}
2769
2770				if ( Expr.preFilter[ type ] ) {
2771					match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
2772
2773					if ( !match ) {
2774						anyFound = found = true;
2775					} else if ( match === true ) {
2776						continue;
2777					}
2778				}
2779
2780				if ( match ) {
2781					for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
2782						if ( item ) {
2783							found = filter( item, match, i, curLoop );
2784							var pass = not ^ !!found;
2785
2786							if ( inplace && found != null ) {
2787								if ( pass ) {
2788									anyFound = true;
2789								} else {
2790									curLoop[i] = false;
2791								}
2792							} else if ( pass ) {
2793								result.push( item );
2794								anyFound = true;
2795							}
2796						}
2797					}
2798				}
2799
2800				if ( found !== undefined ) {
2801					if ( !inplace ) {
2802						curLoop = result;
2803					}
2804
2805					expr = expr.replace( Expr.match[ type ], "" );
2806
2807					if ( !anyFound ) {
2808						return [];
2809					}
2810
2811					break;
2812				}
2813			}
2814		}
2815
2816		// Improper expression
2817		if ( expr === old ) {
2818			if ( anyFound == null ) {
2819				Sizzle.error( expr );
2820			} else {
2821				break;
2822			}
2823		}
2824
2825		old = expr;
2826	}
2827
2828	return curLoop;
2829};
2830
2831Sizzle.error = function( msg ) {
2832	throw "Syntax error, unrecognized expression: " + msg;
2833};
2834
2835var Expr = Sizzle.selectors = {
2836	order: [ "ID", "NAME", "TAG" ],
2837	match: {
2838		ID: /#((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
2839		CLASS: /\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
2840		NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/,
2841		ATTR: /\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
2842		TAG: /^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/,
2843		CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
2844		POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
2845		PSEUDO: /:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
2846	},
2847	leftMatch: {},
2848	attrMap: {
2849		"class": "className",
2850		"for": "htmlFor"
2851	},
2852	attrHandle: {
2853		href: function(elem){
2854			return elem.getAttribute("href");
2855		}
2856	},
2857	relative: {
2858		"+": function(checkSet, part){
2859			var isPartStr = typeof part === "string",
2860				isTag = isPartStr && !/\W/.test(part),
2861				isPartStrNotTag = isPartStr && !isTag;
2862
2863			if ( isTag ) {
2864				part = part.toLowerCase();
2865			}
2866
2867			for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
2868				if ( (elem = checkSet[i]) ) {
2869					while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
2870
2871					checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
2872						elem || false :
2873						elem === part;
2874				}
2875			}
2876
2877			if ( isPartStrNotTag ) {
2878				Sizzle.filter( part, checkSet, true );
2879			}
2880		},
2881		">": function(checkSet, part){
2882			var isPartStr = typeof part === "string";
2883
2884			if ( isPartStr && !/\W/.test(part) ) {
2885				part = part.toLowerCase();
2886
2887				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2888					var elem = checkSet[i];
2889					if ( elem ) {
2890						var parent = elem.parentNode;
2891						checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
2892					}
2893				}
2894			} else {
2895				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2896					var elem = checkSet[i];
2897					if ( elem ) {
2898						checkSet[i] = isPartStr ?
2899							elem.parentNode :
2900							elem.parentNode === part;
2901					}
2902				}
2903
2904				if ( isPartStr ) {
2905					Sizzle.filter( part, checkSet, true );
2906				}
2907			}
2908		},
2909		"": function(checkSet, part, isXML){
2910			var doneName = done++, checkFn = dirCheck;
2911
2912			if ( typeof part === "string" && !/\W/.test(part) ) {
2913				var nodeCheck = part = part.toLowerCase();
2914				checkFn = dirNodeCheck;
2915			}
2916
2917			checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
2918		},
2919		"~": function(checkSet, part, isXML){
2920			var doneName = done++, checkFn = dirCheck;
2921
2922			if ( typeof part === "string" && !/\W/.test(part) ) {
2923				var nodeCheck = part = part.toLowerCase();
2924				checkFn = dirNodeCheck;
2925			}
2926
2927			checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
2928		}
2929	},
2930	find: {
2931		ID: function(match, context, isXML){
2932			if ( typeof context.getElementById !== "undefined" && !isXML ) {
2933				var m = context.getElementById(match[1]);
2934				return m ? [m] : [];
2935			}
2936		},
2937		NAME: function(match, context){
2938			if ( typeof context.getElementsByName !== "undefined" ) {
2939				var ret = [], results = context.getElementsByName(match[1]);
2940
2941				for ( var i = 0, l = results.length; i < l; i++ ) {
2942					if ( results[i].getAttribute("name") === match[1] ) {
2943						ret.push( results[i] );
2944					}
2945				}
2946
2947				return ret.length === 0 ? null : ret;
2948			}
2949		},
2950		TAG: function(match, context){
2951			return context.getElementsByTagName(match[1]);
2952		}
2953	},
2954	preFilter: {
2955		CLASS: function(match, curLoop, inplace, result, not, isXML){
2956			match = " " + match[1].replace(/\\/g, "") + " ";
2957
2958			if ( isXML ) {
2959				return match;
2960			}
2961
2962			for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
2963				if ( elem ) {
2964					if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n]/g, " ").indexOf(match) >= 0) ) {
2965						if ( !inplace ) {
2966							result.push( elem );
2967						}
2968					} else if ( inplace ) {
2969						curLoop[i] = false;
2970					}
2971				}
2972			}
2973
2974			return false;
2975		},
2976		ID: function(match){
2977			return match[1].replace(/\\/g, "");
2978		},
2979		TAG: function(match, curLoop){
2980			return match[1].toLowerCase();
2981		},
2982		CHILD: function(match){
2983			if ( match[1] === "nth" ) {
2984				// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
2985				var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
2986					match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
2987					!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
2988
2989				// calculate the numbers (first)n+(last) including if they are negative
2990				match[2] = (test[1] + (test[2] || 1)) - 0;
2991				match[3] = test[3] - 0;
2992			}
2993
2994			// TODO: Move to normal caching system
2995			match[0] = done++;
2996
2997			return match;
2998		},
2999		ATTR: function(match, curLoop, inplace, result, not, isXML){
3000			var name = match[1].replace(/\\/g, "");
3001			
3002			if ( !isXML && Expr.attrMap[name] ) {
3003				match[1] = Expr.attrMap[name];
3004			}
3005
3006			if ( match[2] === "~=" ) {
3007				match[4] = " " + match[4] + " ";
3008			}
3009
3010			return match;
3011		},
3012		PSEUDO: function(match, curLoop, inplace, result, not){
3013			if ( match[1] === "not" ) {
3014				// If we're dealing with a complex expression, or a simple one
3015				if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
3016					match[3] = Sizzle(match[3], null, null, curLoop);
3017				} else {
3018					var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
3019					if ( !inplace ) {
3020						result.push.apply( result, ret );
3021					}
3022					return false;
3023				}
3024			} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
3025				return true;
3026			}
3027			
3028			return match;
3029		},
3030		POS: function(match){
3031			match.unshift( true );
3032			return match;
3033		}
3034	},
3035	filters: {
3036		enabled: function(elem){
3037			return elem.disabled === false && elem.type !== "hidden";
3038		},
3039		disabled: function(elem){
3040			return elem.disabled === true;
3041		},
3042		checked: function(elem){
3043			return elem.checked === true;
3044		},
3045		selected: function(elem){
3046			// Accessing this property makes selected-by-default
3047			// options in Safari work properly
3048			elem.parentNode.selectedIndex;
3049			return elem.selected === true;
3050		},
3051		parent: function(elem){
3052			return !!elem.firstChild;
3053		},
3054		empty: function(elem){
3055			return !elem.firstChild;
3056		},
3057		has: function(elem, i, match){
3058			return !!Sizzle( match[3], elem ).length;
3059		},
3060		header: function(elem){
3061			return /h\d/i.test( elem.nodeName );
3062		},
3063		text: function(elem){
3064			return "text" === elem.type;
3065		},
3066		radio: function(elem){
3067			return "radio" === elem.type;
3068		},
3069		checkbox: function(elem){
3070			return "checkbox" === elem.type;
3071		},
3072		file: function(elem){
3073			return "file" === elem.type;
3074		},
3075		password: function(elem){
3076			return "password" === elem.type;
3077		},
3078		submit: function(elem){
3079			return "submit" === elem.type;
3080		},
3081		image: function(elem){
3082			return "image" === elem.type;
3083		},
3084		reset: function(elem){
3085			return "reset" === elem.type;
3086		},
3087		button: function(elem){
3088			return "button" === elem.type || elem.nodeName.toLowerCase() === "button";
3089		},
3090		input: function(elem){
3091			return /input|select|textarea|button/i.test(elem.nodeName);
3092		}
3093	},
3094	setFilters: {
3095		first: function(elem, i){
3096			return i === 0;
3097		},
3098		last: function(elem, i, match, array){
3099			return i === array.length - 1;
3100		},
3101		even: function(elem, i){
3102			return i % 2 === 0;
3103		},
3104		odd: function(elem, i){
3105			return i % 2 === 1;
3106		},
3107		lt: function(elem, i, match){
3108			return i < match[3] - 0;
3109		},
3110		gt: function(elem, i, match){
3111			return i > match[3] - 0;
3112		},
3113		nth: function(elem, i, match){
3114			return match[3] - 0 === i;
3115		},
3116		eq: function(elem, i, match){
3117			return match[3] - 0 === i;
3118		}
3119	},
3120	filter: {
3121		PSEUDO: function(elem, match, i, array){
3122			var name = match[1], filter = Expr.filters[ name ];
3123
3124			if ( filter ) {
3125				return filter( elem, i, match, array );
3126			} else if ( name === "contains" ) {
3127				return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0;
3128			} else if ( name === "not" ) {
3129				var not = match[3];
3130
3131				for ( var i = 0, l = not.length; i < l; i++ ) {
3132					if ( not[i] === elem ) {
3133						return false;
3134					}
3135				}
3136
3137				return true;
3138			} else {
3139				Sizzle.error( "Syntax error, unrecognized expression: " + name );
3140			}
3141		},
3142		CHILD: function(elem, match){
3143			var type = match[1], node = elem;
3144			switch (type) {
3145				case 'only':
3146				case 'first':
3147					while ( (node = node.previousSibling) )	 {
3148						if ( node.nodeType === 1 ) { 
3149							return false; 
3150						}
3151					}
3152					if ( type === "first" ) { 
3153						return true; 
3154					}
3155					node = elem;
3156				case 'last':
3157					while ( (node = node.nextSibling) )	 {
3158						if ( node.nodeType === 1 ) { 
3159							return false; 
3160						}
3161					}
3162					return true;
3163				case 'nth':
3164					var first = match[2], last = match[3];
3165
3166					if ( first === 1 && last === 0 ) {
3167						return true;
3168					}
3169					
3170					var doneName = match[0],
3171						parent = elem.parentNode;
3172	
3173					if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
3174						var count = 0;
3175						for ( node = parent.firstChild; node; node = node.nextSibling ) {
3176							if ( node.nodeType === 1 ) {
3177								node.nodeIndex = ++count;
3178							}
3179						} 
3180						parent.sizcache = doneName;
3181					}
3182					
3183					var diff = elem.nodeIndex - last;
3184					if ( first === 0 ) {
3185						return diff === 0;
3186					} else {
3187						return ( diff % first === 0 && diff / first >= 0 );
3188					}
3189			}
3190		},
3191		ID: function(elem, match){
3192			return elem.nodeType === 1 && elem.getAttribute("id") === match;
3193		},
3194		TAG: function(elem, match){
3195			return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
3196		},
3197		CLASS: function(elem, match){
3198			return (" " + (elem.className || elem.getAttribute("class")) + " ")
3199				.indexOf( match ) > -1;
3200		},
3201		ATTR: function(elem, match){
3202			var name = match[1],
3203				result = Expr.attrHandle[ name ] ?
3204					Expr.attrHandle[ name ]( elem ) :
3205					elem[ name ] != null ?
3206						elem[ name ] :
3207						elem.getAttribute( name ),
3208				value = result + "",
3209				type = match[2],
3210				check = match[4];
3211
3212			return result == null ?
3213				type === "!=" :
3214				type === "=" ?
3215				value === check :
3216				type === "*=" ?
3217				value.indexOf(check) >= 0 :
3218				type === "~=" ?
3219				(" " + value + " ").indexOf(check) >= 0 :
3220				!check ?
3221				value && result !== false :
3222				type === "!=" ?
3223				value !== check :
3224				type === "^=" ?
3225				value.indexOf(check) === 0 :
3226				type === "$=" ?
3227				value.substr(value.length - check.length) === check :
3228				type === "|=" ?
3229				value === check || value.substr(0, check.length + 1) === check + "-" :
3230				false;
3231		},
3232		POS: function(elem, match, i, array){
3233			var name = match[2], filter = Expr.setFilters[ name ];
3234
3235			if ( filter ) {
3236				return filter( elem, i, match, array );
3237			}
3238		}
3239	}
3240};
3241
3242var origPOS = Expr.match.POS;
3243
3244for ( var type in Expr.match ) {
3245	Expr.match[ type ] = new RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
3246	Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, function(all, num){
3247		return "\\" + (num - 0 + 1);
3248	}));
3249}
3250
3251var makeArray = function(array, results) {
3252	array = Array.prototype.slice.call( array, 0 );
3253
3254	if ( results ) {
3255		results.push.apply( results, array );
3256		return results;
3257	}
3258	
3259	return array;
3260};
3261
3262// Perform a simple check to determine if the browser is capable of
3263// converting a NodeList to an array using builtin methods.