Nawigacja

root/trunk/Wierszowki/Wierszowki.Web/Scripts/jquery-1.3.1.js @ 752

Odwiedź:

Wersja 752, 114.7 KB (wprowadzona przez marek, 17 years temu)
wiersz

Line
1	/*!
2	* jQuery JavaScript Library v1.3.1
3	* http://jquery.com/
4	*
5	* Copyright (c) 2009 John Resig
6	* Dual licensed under the MIT and GPL licenses.
7	* http://docs.jquery.com/License
8	*
9	* Date: 2009-01-21 20:42:16 -0500 (Wed, 21 Jan 2009)
10	* Revision: 6158
11	*/
12	(function(){
13
14	var
15	// Will speed up references to window, and allows munging its name.
16	window = this,
17	// Will speed up references to undefined, and allows munging its name.
18	undefined,
19	// Map over jQuery in case of overwrite
20	_jQuery = window.jQuery,
21	// Map over the $ in case of overwrite
22	_$ = window.$,
23
24	jQuery = window.jQuery = window.$ = function( selector, context ) {
25	// The jQuery object is actually just the init constructor 'enhanced'
26	return new jQuery.fn.init( selector, context );
27	},
28
29	// A simple way to check for HTML strings or ID strings
30	// (both of which we optimize for)
31	quickExpr = /^[^<](<(.\|\s)+>)[^>]$\|^#([\w-]+)$/,
32	// Is it a simple selector
33	isSimple = /^.[^:#\[\.,]*$/;
34
35	jQuery.fn = jQuery.prototype = {
36	init: function( selector, context ) {
37	// Make sure that a selection was provided
38	selector = selector \|\| document;
39
40	// Handle $(DOMElement)
41	if ( selector.nodeType ) {
42	this[0] = selector;
43	this.length = 1;
44	this.context = selector;
45	return this;
46	}
47	// Handle HTML strings
48	if ( typeof selector === "string" ) {
49	// Are we dealing with HTML string or an ID?
50	var match = quickExpr.exec( selector );
51
52	// Verify a match, and that no context was specified for #id
53	if ( match && (match[1] \|\| !context) ) {
54
55	// HANDLE: $(html) -> $(array)
56	if ( match[1] )
57	selector = jQuery.clean( [ match[1] ], context );
58
59	// HANDLE: $("#id")
60	else {
61	var elem = document.getElementById( match[3] );
62
63	// Handle the case where IE and Opera return items
64	// by name instead of ID
65	if ( elem && elem.id != match[3] )
66	return jQuery().find( selector );
67
68	// Otherwise, we inject the element directly into the jQuery object
69	var ret = jQuery( elem \|\| [] );
70	ret.context = document;
71	ret.selector = selector;
72	return ret;
73	}
74
75	// HANDLE: $(expr, [context])
76	// (which is just equivalent to: $(content).find(expr)
77	} else
78	return jQuery( context ).find( selector );
79
80	// HANDLE: $(function)
81	// Shortcut for document ready
82	} else if ( jQuery.isFunction( selector ) )
83	return jQuery( document ).ready( selector );
84
85	// Make sure that old selector state is passed along
86	if ( selector.selector && selector.context ) {
87	this.selector = selector.selector;
88	this.context = selector.context;
89	}
90
91	return this.setArray(jQuery.makeArray(selector));
92	},
93
94	// Start with an empty selector
95	selector: "",
96
97	// The current version of jQuery being used
98	jquery: "1.3.1",
99
100	// The number of elements contained in the matched element set
101	size: function() {
102	return this.length;
103	},
104
105	// Get the Nth element in the matched element set OR
106	// Get the whole matched element set as a clean array
107	get: function( num ) {
108	return num === undefined ?
109
110	// Return a 'clean' array
111	jQuery.makeArray( this ) :
112
113	// Return just the object
114	this[ num ];
115	},
116
117	// Take an array of elements and push it onto the stack
118	// (returning the new matched element set)
119	pushStack: function( elems, name, selector ) {
120	// Build a new jQuery matched element set
121	var ret = jQuery( elems );
122
123	// Add the old object onto the stack (as a reference)
124	ret.prevObject = this;
125
126	ret.context = this.context;
127
128	if ( name === "find" )
129	ret.selector = this.selector + (this.selector ? " " : "") + selector;
130	else if ( name )
131	ret.selector = this.selector + "." + name + "(" + selector + ")";
132
133	// Return the newly-formed element set
134	return ret;
135	},
136
137	// Force the current matched set of elements to become
138	// the specified array of elements (destroying the stack in the process)
139	// You should use pushStack() in order to do this, but maintain the stack
140	setArray: function( elems ) {
141	// Resetting the length to 0, then using the native Array push
142	// is a super-fast way to populate an object with array-like properties
143	this.length = 0;
144	Array.prototype.push.apply( this, elems );
145
146	return this;
147	},
148
149	// Execute a callback for every element in the matched set.
150	// (You can seed the arguments with an array of args, but this is
151	// only used internally.)
152	each: function( callback, args ) {
153	return jQuery.each( this, callback, args );
154	},
155
156	// Determine the position of an element within
157	// the matched set of elements
158	index: function( elem ) {
159	// Locate the position of the desired element
160	return jQuery.inArray(
161	// If it receives a jQuery object, the first element is used
162	elem && elem.jquery ? elem[0] : elem
163	, this );
164	},
165
166	attr: function( name, value, type ) {
167	var options = name;
168
169	// Look for the case where we're accessing a style value
170	if ( typeof name === "string" )
171	if ( value === undefined )
172	return this[0] && jQuery[ type \|\| "attr" ]( this[0], name );
173
174	else {
175	options = {};
176	options[ name ] = value;
177	}
178
179	// Check to see if we're setting style values
180	return this.each(function(i){
181	// Set all the styles
182	for ( name in options )
183	jQuery.attr(
184	type ?
185	this.style :
186	this,
187	name, jQuery.prop( this, options[ name ], type, i, name )
188	);
189	});
190	},
191
192	css: function( key, value ) {
193	// ignore negative width and height values
194	if ( (key == 'width' \|\| key == 'height') && parseFloat(value) < 0 )
195	value = undefined;
196	return this.attr( key, value, "curCSS" );
197	},
198
199	text: function( text ) {
200	if ( typeof text !== "object" && text != null )
201	return this.empty().append( (this[0] && this[0].ownerDocument \|\| document).createTextNode( text ) );
202
203	var ret = "";
204
205	jQuery.each( text \|\| this, function(){
206	jQuery.each( this.childNodes, function(){
207	if ( this.nodeType != 8 )
208	ret += this.nodeType != 1 ?
209	this.nodeValue :
210	jQuery.fn.text( [ this ] );
211	});
212	});
213
214	return ret;
215	},
216
217	wrapAll: function( html ) {
218	if ( this[0] ) {
219	// The elements to wrap the target around
220	var wrap = jQuery( html, this[0].ownerDocument ).clone();
221
222	if ( this[0].parentNode )
223	wrap.insertBefore( this[0] );
224
225	wrap.map(function(){
226	var elem = this;
227
228	while ( elem.firstChild )
229	elem = elem.firstChild;
230
231	return elem;
232	}).append(this);
233	}
234
235	return this;
236	},
237
238	wrapInner: function( html ) {
239	return this.each(function(){
240	jQuery( this ).contents().wrapAll( html );
241	});
242	},
243
244	wrap: function( html ) {
245	return this.each(function(){
246	jQuery( this ).wrapAll( html );
247	});
248	},
249
250	append: function() {
251	return this.domManip(arguments, true, function(elem){
252	if (this.nodeType == 1)
253	this.appendChild( elem );
254	});
255	},
256
257	prepend: function() {
258	return this.domManip(arguments, true, function(elem){
259	if (this.nodeType == 1)
260	this.insertBefore( elem, this.firstChild );
261	});
262	},
263
264	before: function() {
265	return this.domManip(arguments, false, function(elem){
266	this.parentNode.insertBefore( elem, this );
267	});
268	},
269
270	after: function() {
271	return this.domManip(arguments, false, function(elem){
272	this.parentNode.insertBefore( elem, this.nextSibling );
273	});
274	},
275
276	end: function() {
277	return this.prevObject \|\| jQuery( [] );
278	},
279
280	// For internal use only.
281	// Behaves like an Array's .push method, not like a jQuery method.
282	push: [].push,
283
284	find: function( selector ) {
285	if ( this.length === 1 && !/,/.test(selector) ) {
286	var ret = this.pushStack( [], "find", selector );
287	ret.length = 0;
288	jQuery.find( selector, this[0], ret );
289	return ret;
290	} else {
291	var elems = jQuery.map(this, function(elem){
292	return jQuery.find( selector, elem );
293	});
294
295	return this.pushStack( /[^+>] [^+>]/.test( selector ) ?
296	jQuery.unique( elems ) :
297	elems, "find", selector );
298	}
299	},
300
301	clone: function( events ) {
302	// Do the clone
303	var ret = this.map(function(){
304	if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
305	// IE copies events bound via attachEvent when
306	// using cloneNode. Calling detachEvent on the
307	// clone will also remove the events from the orignal
308	// In order to get around this, we use innerHTML.
309	// Unfortunately, this means some modifications to
310	// attributes in IE that are actually only stored
311	// as properties will not be copied (such as the
312	// the name attribute on an input).
313	var clone = this.cloneNode(true),
314	container = document.createElement("div");
315	container.appendChild(clone);
316	return jQuery.clean([container.innerHTML])[0];
317	} else
318	return this.cloneNode(true);
319	});
320
321	// Need to set the expando to null on the cloned set if it exists
322	// removeData doesn't work here, IE removes it from the original as well
323	// this is primarily for IE but the data expando shouldn't be copied over in any browser
324	var clone = ret.find("*").andSelf().each(function(){
325	if ( this[ expando ] !== undefined )
326	this[ expando ] = null;
327	});
328
329	// Copy the events from the original to the clone
330	if ( events === true )
331	this.find("*").andSelf().each(function(i){
332	if (this.nodeType == 3)
333	return;
334	var events = jQuery.data( this, "events" );
335
336	for ( var type in events )
337	for ( var handler in events[ type ] )
338	jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
339	});
340
341	// Return the cloned set
342	return ret;
343	},
344
345	filter: function( selector ) {
346	return this.pushStack(
347	jQuery.isFunction( selector ) &&
348	jQuery.grep(this, function(elem, i){
349	return selector.call( elem, i );
350	}) \|\|
351
352	jQuery.multiFilter( selector, jQuery.grep(this, function(elem){
353	return elem.nodeType === 1;
354	}) ), "filter", selector );
355	},
356
357	closest: function( selector ) {
358	var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null;
359
360	return this.map(function(){
361	var cur = this;
362	while ( cur && cur.ownerDocument ) {
363	if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) )
364	return cur;
365	cur = cur.parentNode;
366	}
367	});
368	},
369
370	not: function( selector ) {
371	if ( typeof selector === "string" )
372	// test special case where just one selector is passed in
373	if ( isSimple.test( selector ) )
374	return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector );
375	else
376	selector = jQuery.multiFilter( selector, this );
377
378	var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
379	return this.filter(function() {
380	return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
381	});
382	},
383
384	add: function( selector ) {
385	return this.pushStack( jQuery.unique( jQuery.merge(
386	this.get(),
387	typeof selector === "string" ?
388	jQuery( selector ) :
389	jQuery.makeArray( selector )
390	)));
391	},
392
393	is: function( selector ) {
394	return !!selector && jQuery.multiFilter( selector, this ).length > 0;
395	},
396
397	hasClass: function( selector ) {
398	return !!selector && this.is( "." + selector );
399	},
400
401	val: function( value ) {
402	if ( value === undefined ) {
403	var elem = this[0];
404
405	if ( elem ) {
406	if( jQuery.nodeName( elem, 'option' ) )
407	return (elem.attributes.value \|\| {}).specified ? elem.value : elem.text;
408
409	// We need to handle select boxes special
410	if ( jQuery.nodeName( elem, "select" ) ) {
411	var index = elem.selectedIndex,
412	values = [],
413	options = elem.options,
414	one = elem.type == "select-one";
415
416	// Nothing was selected
417	if ( index < 0 )
418	return null;
419
420	// Loop through all the selected options
421	for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
422	var option = options[ i ];
423
424	if ( option.selected ) {
425	// Get the specifc value for the option
426	value = jQuery(option).val();
427
428	// We don't need an array for one selects
429	if ( one )
430	return value;
431
432	// Multi-Selects return an array
433	values.push( value );
434	}
435	}
436
437	return values;
438	}
439
440	// Everything else, we just grab the value
441	return (elem.value \|\| "").replace(/\r/g, "");
442
443	}
444
445	return undefined;
446	}
447
448	if ( typeof value === "number" )
449	value += '';
450
451	return this.each(function(){
452	if ( this.nodeType != 1 )
453	return;
454
455	if ( jQuery.isArray(value) && /radio\|checkbox/.test( this.type ) )
456	this.checked = (jQuery.inArray(this.value, value) >= 0 \|\|
457	jQuery.inArray(this.name, value) >= 0);
458
459	else if ( jQuery.nodeName( this, "select" ) ) {
460	var values = jQuery.makeArray(value);
461
462	jQuery( "option", this ).each(function(){
463	this.selected = (jQuery.inArray( this.value, values ) >= 0 \|\|
464	jQuery.inArray( this.text, values ) >= 0);
465	});
466
467	if ( !values.length )
468	this.selectedIndex = -1;
469
470	} else
471	this.value = value;
472	});
473	},
474
475	html: function( value ) {
476	return value === undefined ?
477	(this[0] ?
478	this[0].innerHTML :
479	null) :
480	this.empty().append( value );
481	},
482
483	replaceWith: function( value ) {
484	return this.after( value ).remove();
485	},
486
487	eq: function( i ) {
488	return this.slice( i, +i + 1 );
489	},
490
491	slice: function() {
492	return this.pushStack( Array.prototype.slice.apply( this, arguments ),
493	"slice", Array.prototype.slice.call(arguments).join(",") );
494	},
495
496	map: function( callback ) {
497	return this.pushStack( jQuery.map(this, function(elem, i){
498	return callback.call( elem, i, elem );
499	}));
500	},
501
502	andSelf: function() {
503	return this.add( this.prevObject );
504	},
505
506	domManip: function( args, table, callback ) {
507	if ( this[0] ) {
508	var fragment = (this[0].ownerDocument \|\| this[0]).createDocumentFragment(),
509	scripts = jQuery.clean( args, (this[0].ownerDocument \|\| this[0]), fragment ),
510	first = fragment.firstChild,
511	extra = this.length > 1 ? fragment.cloneNode(true) : fragment;
512
513	if ( first )
514	for ( var i = 0, l = this.length; i < l; i++ )
515	callback.call( root(this[i], first), i > 0 ? extra.cloneNode(true) : fragment );
516
517	if ( scripts )
518	jQuery.each( scripts, evalScript );
519	}
520
521	return this;
522
523	function root( elem, cur ) {
524	return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ?
525	(elem.getElementsByTagName("tbody")[0] \|\|
526	elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
527	elem;
528	}
529	}
530	};
531
532	// Give the init function the jQuery prototype for later instantiation
533	jQuery.fn.init.prototype = jQuery.fn;
534
535	function evalScript( i, elem ) {
536	if ( elem.src )
537	jQuery.ajax({
538	url: elem.src,
539	async: false,
540	dataType: "script"
541	});
542
543	else
544	jQuery.globalEval( elem.text \|\| elem.textContent \|\| elem.innerHTML \|\| "" );
545
546	if ( elem.parentNode )
547	elem.parentNode.removeChild( elem );
548	}
549
550	function now(){
551	return +new Date;
552	}
553
554	jQuery.extend = jQuery.fn.extend = function() {
555	// copy reference to target object
556	var target = arguments[0] \|\| {}, i = 1, length = arguments.length, deep = false, options;
557
558	// Handle a deep copy situation
559	if ( typeof target === "boolean" ) {
560	deep = target;
561	target = arguments[1] \|\| {};
562	// skip the boolean and the target
563	i = 2;
564	}
565
566	// Handle case when target is a string or something (possible in deep copy)
567	if ( typeof target !== "object" && !jQuery.isFunction(target) )
568	target = {};
569
570	// extend jQuery itself if only one argument is passed
571	if ( length == i ) {
572	target = this;
573	--i;
574	}
575
576	for ( ; i < length; i++ )
577	// Only deal with non-null/undefined values
578	if ( (options = arguments[ i ]) != null )
579	// Extend the base object
580	for ( var name in options ) {
581	var src = target[ name ], copy = options[ name ];
582
583	// Prevent never-ending loop
584	if ( target === copy )
585	continue;
586
587	// Recurse if we're merging object values
588	if ( deep && copy && typeof copy === "object" && !copy.nodeType )
589	target[ name ] = jQuery.extend( deep,
590	// Never move original objects, clone them
591	src \|\| ( copy.length != null ? [ ] : { } )
592	, copy );
593
594	// Don't bring in undefined values
595	else if ( copy !== undefined )
596	target[ name ] = copy;
597
598	}
599
600	// Return the modified object
601	return target;
602	};
603
604	// exclude the following css properties to add px
605	var exclude = /z-?index\|font-?weight\|opacity\|zoom\|line-?height/i,
606	// cache defaultView
607	defaultView = document.defaultView \|\| {},
608	toString = Object.prototype.toString;
609
610	jQuery.extend({
611	noConflict: function( deep ) {
612	window.$ = _$;
613
614	if ( deep )
615	window.jQuery = _jQuery;
616
617	return jQuery;
618	},
619
620	// See test/unit/core.js for details concerning isFunction.
621	// Since version 1.3, DOM methods and functions like alert
622	// aren't supported. They return false on IE (#2968).
623	isFunction: function( obj ) {
624	return toString.call(obj) === "[object Function]";
625	},
626
627	isArray: function( obj ) {
628	return toString.call(obj) === "[object Array]";
629	},
630
631	// check if an element is in a (or is an) XML document
632	isXMLDoc: function( elem ) {
633	return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" \|\|
634	!!elem.ownerDocument && jQuery.isXMLDoc( elem.ownerDocument );
635	},
636
637	// Evalulates a script in a global context
638	globalEval: function( data ) {
639	data = jQuery.trim( data );
640
641	if ( data ) {
642	// Inspired by code by Andrea Giammarchi
643	// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
644	var head = document.getElementsByTagName("head")[0] \|\| document.documentElement,
645	script = document.createElement("script");
646
647	script.type = "text/javascript";
648	if ( jQuery.support.scriptEval )
649	script.appendChild( document.createTextNode( data ) );
650	else
651	script.text = data;
652
653	// Use insertBefore instead of appendChild to circumvent an IE6 bug.
654	// This arises when a base node is used (#2709).
655	head.insertBefore( script, head.firstChild );
656	head.removeChild( script );
657	}
658	},
659
660	nodeName: function( elem, name ) {
661	return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
662	},
663
664	// args is for internal usage only
665	each: function( object, callback, args ) {
666	var name, i = 0, length = object.length;
667
668	if ( args ) {
669	if ( length === undefined ) {
670	for ( name in object )
671	if ( callback.apply( object[ name ], args ) === false )
672	break;
673	} else
674	for ( ; i < length; )
675	if ( callback.apply( object[ i++ ], args ) === false )
676	break;
677
678	// A special, fast, case for the most common use of each
679	} else {
680	if ( length === undefined ) {
681	for ( name in object )
682	if ( callback.call( object[ name ], name, object[ name ] ) === false )
683	break;
684	} else
685	for ( var value = object[0];
686	i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
687	}
688
689	return object;
690	},
691
692	prop: function( elem, value, type, i, name ) {
693	// Handle executable functions
694	if ( jQuery.isFunction( value ) )
695	value = value.call( elem, i );
696
697	// Handle passing in a number to a CSS property
698	return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ?
699	value + "px" :
700	value;
701	},
702
703	className: {
704	// internal only, use addClass("class")
705	add: function( elem, classNames ) {
706	jQuery.each((classNames \|\| "").split(/\s+/), function(i, className){
707	if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
708	elem.className += (elem.className ? " " : "") + className;
709	});
710	},
711
712	// internal only, use removeClass("class")
713	remove: function( elem, classNames ) {
714	if (elem.nodeType == 1)
715	elem.className = classNames !== undefined ?
716	jQuery.grep(elem.className.split(/\s+/), function(className){
717	return !jQuery.className.has( classNames, className );
718	}).join(" ") :
719	"";
720	},
721
722	// internal only, use hasClass("class")
723	has: function( elem, className ) {
724	return elem && jQuery.inArray( className, (elem.className \|\| elem).toString().split(/\s+/) ) > -1;
725	}
726	},
727
728	// A method for quickly swapping in/out CSS properties to get correct calculations
729	swap: function( elem, options, callback ) {
730	var old = {};
731	// Remember the old values, and insert the new ones
732	for ( var name in options ) {
733	old[ name ] = elem.style[ name ];
734	elem.style[ name ] = options[ name ];
735	}
736
737	callback.call( elem );
738
739	// Revert the old values
740	for ( var name in options )
741	elem.style[ name ] = old[ name ];
742	},
743
744	css: function( elem, name, force ) {
745	if ( name == "width" \|\| name == "height" ) {
746	var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
747
748	function getWH() {
749	val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
750	var padding = 0, border = 0;
751	jQuery.each( which, function() {
752	padding += parseFloat(jQuery.curCSS( elem, "padding" + this, true)) \|\| 0;
753	border += parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) \|\| 0;
754	});
755	val -= Math.round(padding + border);
756	}
757
758	if ( jQuery(elem).is(":visible") )
759	getWH();
760	else
761	jQuery.swap( elem, props, getWH );
762
763	return Math.max(0, val);
764	}
765
766	return jQuery.curCSS( elem, name, force );
767	},
768
769	curCSS: function( elem, name, force ) {
770	var ret, style = elem.style;
771
772	// We need to handle opacity special in IE
773	if ( name == "opacity" && !jQuery.support.opacity ) {
774	ret = jQuery.attr( style, "opacity" );
775
776	return ret == "" ?
777	"1" :
778	ret;
779	}
780
781	// Make sure we're using the right name for getting the float value
782	if ( name.match( /float/i ) )
783	name = styleFloat;
784
785	if ( !force && style && style[ name ] )
786	ret = style[ name ];
787
788	else if ( defaultView.getComputedStyle ) {
789
790	// Only "float" is needed here
791	if ( name.match( /float/i ) )
792	name = "float";
793
794	name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
795
796	var computedStyle = defaultView.getComputedStyle( elem, null );
797
798	if ( computedStyle )
799	ret = computedStyle.getPropertyValue( name );
800
801	// We should always get a number back from opacity
802	if ( name == "opacity" && ret == "" )
803	ret = "1";
804
805	} else if ( elem.currentStyle ) {
806	var camelCase = name.replace(/\-(\w)/g, function(all, letter){
807	return letter.toUpperCase();
808	});
809
810	ret = elem.currentStyle[ name ] \|\| elem.currentStyle[ camelCase ];
811
812	// From the awesome hack by Dean Edwards
813	// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
814
815	// If we're not dealing with a regular pixel number
816	// but a number that has a weird ending, we need to convert it to pixels
817	if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
818	// Remember the original values
819	var left = style.left, rsLeft = elem.runtimeStyle.left;
820
821	// Put in the new values to get a computed value out
822	elem.runtimeStyle.left = elem.currentStyle.left;
823	style.left = ret \|\| 0;
824	ret = style.pixelLeft + "px";
825
826	// Revert the changed values
827	style.left = left;
828	elem.runtimeStyle.left = rsLeft;
829	}
830	}
831
832	return ret;
833	},
834
835	clean: function( elems, context, fragment ) {
836	context = context \|\| document;
837
838	// !context.createElement fails in IE with an error but returns typeof 'object'
839	if ( typeof context.createElement === "undefined" )
840	context = context.ownerDocument \|\| context[0] && context[0].ownerDocument \|\| document;
841
842	// If a single string is passed in and it's a single tag
843	// just do a createElement and skip the rest
844	if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) {
845	var match = /^<(\w+)\s*\/?>$/.exec(elems[0]);
846	if ( match )
847	return [ context.createElement( match[1] ) ];
848	}
849
850	var ret = [], scripts = [], div = context.createElement("div");
851
852	jQuery.each(elems, function(i, elem){
853	if ( typeof elem === "number" )
854	elem += '';
855
856	if ( !elem )
857	return;
858
859	// Convert html string into DOM nodes
860	if ( typeof elem === "string" ) {
861	// Fix "XHTML"-style tags in all browsers
862	elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
863	return tag.match(/^(abbr\|br\|col\|img\|input\|link\|meta\|param\|hr\|area\|embed)$/i) ?
864	all :
865	front + "></" + tag + ">";
866	});
867
868	// Trim whitespace, otherwise indexOf won't work as expected
869	var tags = jQuery.trim( elem ).toLowerCase();
870
871	var wrap =
872	// option or optgroup
873	!tags.indexOf("<opt") &&
874	[ 1, "<select multiple='multiple'>", "</select>" ] \|\|
875
876	!tags.indexOf("<leg") &&
877	[ 1, "<fieldset>", "</fieldset>" ] \|\|
878
879	tags.match(/^<(thead\|tbody\|tfoot\|colg\|cap)/) &&
880	[ 1, "<table>", "</table>" ] \|\|
881
882	!tags.indexOf("<tr") &&
883	[ 2, "<table><tbody>", "</tbody></table>" ] \|\|
884
885	// <thead> matched above
886	(!tags.indexOf("<td") \|\| !tags.indexOf("<th")) &&
887	[ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] \|\|
888
889	!tags.indexOf("<col") &&
890	[ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] \|\|
891
892	// IE can't serialize <link> and <script> tags normally
893	!jQuery.support.htmlSerialize &&
894	[ 1, "div<div>", "</div>" ] \|\|
895
896	[ 0, "", "" ];
897
898	// Go to html and back, then peel off extra wrappers
899	div.innerHTML = wrap[1] + elem + wrap[2];
900
901	// Move to the right depth
902	while ( wrap[0]-- )
903	div = div.lastChild;
904
905	// Remove IE's autoinserted <tbody> from table fragments
906	if ( !jQuery.support.tbody ) {
907
908	// String was a <table>, may have spurious <tbody>
909	var tbody = !tags.indexOf("<table") && tags.indexOf("<tbody") < 0 ?
910	div.firstChild && div.firstChild.childNodes :
911
912	// String was a bare <thead> or <tfoot>
913	wrap[1] == "<table>" && tags.indexOf("<tbody") < 0 ?
914	div.childNodes :
915	[];
916
917	for ( var j = tbody.length - 1; j >= 0 ; --j )
918	if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
919	tbody[ j ].parentNode.removeChild( tbody[ j ] );
920
921	}
922
923	// IE completely kills leading whitespace when innerHTML is used
924	if ( !jQuery.support.leadingWhitespace && /^\s/.test( elem ) )
925	div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
926
927	elem = jQuery.makeArray( div.childNodes );
928	}
929
930	if ( elem.nodeType )
931	ret.push( elem );
932	else
933	ret = jQuery.merge( ret, elem );
934
935	});
936
937	if ( fragment ) {
938	for ( var i = 0; ret[i]; i++ ) {
939	if ( jQuery.nodeName( ret[i], "script" ) && (!ret[i].type \|\| ret[i].type.toLowerCase() === "text/javascript") ) {
940	scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
941	} else {
942	if ( ret[i].nodeType === 1 )
943	ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
944	fragment.appendChild( ret[i] );
945	}
946	}
947
948	return scripts;
949	}
950
951	return ret;
952	},
953
954	attr: function( elem, name, value ) {
955	// don't set attributes on text and comment nodes
956	if (!elem \|\| elem.nodeType == 3 \|\| elem.nodeType == 8)
957	return undefined;
958
959	var notxml = !jQuery.isXMLDoc( elem ),
960	// Whether we are setting (or getting)
961	set = value !== undefined;
962
963	// Try to normalize/fix the name
964	name = notxml && jQuery.props[ name ] \|\| name;
965
966	// Only do all the following if this is a node (faster for style)
967	// IE elem.getAttribute passes even for style
968	if ( elem.tagName ) {
969
970	// These attributes require special treatment
971	var special = /href\|src\|style/.test( name );
972
973	// Safari mis-reports the default selected property of a hidden option
974	// Accessing the parent's selectedIndex property fixes it
975	if ( name == "selected" && elem.parentNode )
976	elem.parentNode.selectedIndex;
977
978	// If applicable, access the attribute via the DOM 0 way
979	if ( name in elem && notxml && !special ) {
980	if ( set ){
981	// We can't allow the type property to be changed (since it causes problems in IE)
982	if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
983	throw "type property can't be changed";
984
985	elem[ name ] = value;
986	}
987
988	// browsers index elements by id/name on forms, give priority to attributes.
989	if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
990	return elem.getAttributeNode( name ).nodeValue;
991
992	// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
993	// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
994	if ( name == "tabIndex" ) {
995	var attributeNode = elem.getAttributeNode( "tabIndex" );
996	return attributeNode && attributeNode.specified
997	? attributeNode.value
998	: elem.nodeName.match(/(button\|input\|object\|select\|textarea)/i)
999	? 0
1000	: elem.nodeName.match(/^(a\|area)$/i) && elem.href
1001	? 0
1002	: undefined;
1003	}
1004
1005	return elem[ name ];
1006	}
1007
1008	if ( !jQuery.support.style && notxml && name == "style" )
1009	return jQuery.attr( elem.style, "cssText", value );
1010
1011	if ( set )
1012	// convert the value to a string (all browsers do this but IE) see #1070
1013	elem.setAttribute( name, "" + value );
1014
1015	var attr = !jQuery.support.hrefNormalized && notxml && special
1016	// Some attributes require a special call on IE
1017	? elem.getAttribute( name, 2 )
1018	: elem.getAttribute( name );
1019
1020	// Non-existent attributes return null, we normalize to undefined
1021	return attr === null ? undefined : attr;
1022	}
1023
1024	// elem is actually elem.style ... set the style
1025
1026	// IE uses filters for opacity
1027	if ( !jQuery.support.opacity && name == "opacity" ) {
1028	if ( set ) {
1029	// IE has trouble with opacity if it does not have layout
1030	// Force it by setting the zoom level
1031	elem.zoom = 1;
1032
1033	// Set the alpha filter to set the opacity
1034	elem.filter = (elem.filter \|\| "").replace( /alpha\([^)]*\)/, "" ) +
1035	(parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
1036	}
1037
1038	return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
1039	(parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
1040	"";
1041	}
1042
1043	name = name.replace(/-([a-z])/ig, function(all, letter){
1044	return letter.toUpperCase();
1045	});
1046
1047	if ( set )
1048	elem[ name ] = value;
1049
1050	return elem[ name ];
1051	},
1052
1053	trim: function( text ) {
1054	return (text \|\| "").replace( /^\s+\|\s+$/g, "" );
1055	},
1056
1057	makeArray: function( array ) {
1058	var ret = [];
1059
1060	if( array != null ){
1061	var i = array.length;
1062	// The window, strings (and functions) also have 'length'
1063	if( i == null \|\| typeof array === "string" \|\| jQuery.isFunction(array) \|\| array.setInterval )
1064	ret[0] = array;
1065	else
1066	while( i )
1067	ret[--i] = array[i];
1068	}
1069
1070	return ret;
1071	},
1072
1073	inArray: function( elem, array ) {
1074	for ( var i = 0, length = array.length; i < length; i++ )
1075	// Use === because on IE, window == document
1076	if ( array[ i ] === elem )
1077	return i;
1078
1079	return -1;
1080	},
1081
1082	merge: function( first, second ) {
1083	// We have to loop this way because IE & Opera overwrite the length
1084	// expando of getElementsByTagName
1085	var i = 0, elem, pos = first.length;
1086	// Also, we need to make sure that the correct elements are being returned
1087	// (IE returns comment nodes in a '*' query)
1088	if ( !jQuery.support.getAll ) {
1089	while ( (elem = second[ i++ ]) != null )
1090	if ( elem.nodeType != 8 )
1091	first[ pos++ ] = elem;
1092
1093	} else
1094	while ( (elem = second[ i++ ]) != null )
1095	first[ pos++ ] = elem;
1096
1097	return first;
1098	},
1099
1100	unique: function( array ) {
1101	var ret = [], done = {};
1102
1103	try {
1104
1105	for ( var i = 0, length = array.length; i < length; i++ ) {
1106	var id = jQuery.data( array[ i ] );
1107
1108	if ( !done[ id ] ) {
1109	done[ id ] = true;
1110	ret.push( array[ i ] );
1111	}
1112	}
1113
1114	} catch( e ) {
1115	ret = array;
1116	}
1117
1118	return ret;
1119	},
1120
1121	grep: function( elems, callback, inv ) {
1122	var ret = [];
1123
1124	// Go through the array, only saving the items
1125	// that pass the validator function
1126	for ( var i = 0, length = elems.length; i < length; i++ )
1127	if ( !inv != !callback( elems[ i ], i ) )
1128	ret.push( elems[ i ] );
1129
1130	return ret;
1131	},
1132
1133	map: function( elems, callback ) {
1134	var ret = [];
1135
1136	// Go through the array, translating each of the items to their
1137	// new value (or values).
1138	for ( var i = 0, length = elems.length; i < length; i++ ) {
1139	var value = callback( elems[ i ], i );
1140
1141	if ( value != null )
1142	ret[ ret.length ] = value;
1143	}
1144
1145	return ret.concat.apply( [], ret );
1146	}
1147	});
1148
1149	// Use of jQuery.browser is deprecated.
1150	// It's included for backwards compatibility and plugins,
1151	// although they should work to migrate away.
1152
1153	var userAgent = navigator.userAgent.toLowerCase();
1154
1155	// Figure out what browser is being used
1156	jQuery.browser = {
1157	version: (userAgent.match( /.+(?:rv\|it\|ra\|ie)[\/: ]([\d.]+)/ ) \|\| [0,'0'])[1],
1158	safari: /webkit/.test( userAgent ),
1159	opera: /opera/.test( userAgent ),
1160	msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
1161	mozilla: /mozilla/.test( userAgent ) && !/(compatible\|webkit)/.test( userAgent )
1162	};
1163
1164	jQuery.each({
1165	parent: function(elem){return elem.parentNode;},
1166	parents: function(elem){return jQuery.dir(elem,"parentNode");},
1167	next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
1168	prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
1169	nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
1170	prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
1171	siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
1172	children: function(elem){return jQuery.sibling(elem.firstChild);},
1173	contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument\|\|elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
1174	}, function(name, fn){
1175	jQuery.fn[ name ] = function( selector ) {
1176	var ret = jQuery.map( this, fn );
1177
1178	if ( selector && typeof selector == "string" )
1179	ret = jQuery.multiFilter( selector, ret );
1180
1181	return this.pushStack( jQuery.unique( ret ), name, selector );
1182	};
1183	});
1184
1185	jQuery.each({
1186	appendTo: "append",
1187	prependTo: "prepend",
1188	insertBefore: "before",
1189	insertAfter: "after",
1190	replaceAll: "replaceWith"
1191	}, function(name, original){
1192	jQuery.fn[ name ] = function() {
1193	var args = arguments;
1194
1195	return this.each(function(){
1196	for ( var i = 0, length = args.length; i < length; i++ )
1197	jQuery( args[ i ] )[ original ]( this );
1198	});
1199	};
1200	});
1201
1202	jQuery.each({
1203	removeAttr: function( name ) {
1204	jQuery.attr( this, name, "" );
1205	if (this.nodeType == 1)
1206	this.removeAttribute( name );
1207	},
1208
1209	addClass: function( classNames ) {
1210	jQuery.className.add( this, classNames );
1211	},
1212
1213	removeClass: function( classNames ) {
1214	jQuery.className.remove( this, classNames );
1215	},
1216
1217	toggleClass: function( classNames, state ) {
1218	if( typeof state !== "boolean" )
1219	state = !jQuery.className.has( this, classNames );
1220	jQuery.className[ state ? "add" : "remove" ]( this, classNames );
1221	},
1222
1223	remove: function( selector ) {
1224	if ( !selector \|\| jQuery.filter( selector, [ this ] ).length ) {
1225	// Prevent memory leaks
1226	jQuery( "*", this ).add([this]).each(function(){
1227	jQuery.event.remove(this);
1228	jQuery.removeData(this);
1229	});
1230	if (this.parentNode)
1231	this.parentNode.removeChild( this );
1232	}
1233	},
1234
1235	empty: function() {
1236	// Remove element nodes and prevent memory leaks
1237	jQuery( ">*", this ).remove();
1238
1239	// Remove any remaining nodes
1240	while ( this.firstChild )
1241	this.removeChild( this.firstChild );
1242	}
1243	}, function(name, fn){
1244	jQuery.fn[ name ] = function(){
1245	return this.each( fn, arguments );
1246	};
1247	});
1248
1249	// Helper function used by the dimensions and offset modules
1250	function num(elem, prop) {
1251	return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) \|\| 0;
1252	}
1253	var expando = "jQuery" + now(), uuid = 0, windowData = {};
1254
1255	jQuery.extend({
1256	cache: {},
1257
1258	data: function( elem, name, data ) {
1259	elem = elem == window ?
1260	windowData :
1261	elem;
1262
1263	var id = elem[ expando ];
1264
1265	// Compute a unique ID for the element
1266	if ( !id )
1267	id = elem[ expando ] = ++uuid;
1268
1269	// Only generate the data cache if we're
1270	// trying to access or manipulate it
1271	if ( name && !jQuery.cache[ id ] )
1272	jQuery.cache[ id ] = {};
1273
1274	// Prevent overriding the named cache with undefined values
1275	if ( data !== undefined )
1276	jQuery.cache[ id ][ name ] = data;
1277
1278	// Return the named cache data, or the ID for the element
1279	return name ?
1280	jQuery.cache[ id ][ name ] :
1281	id;
1282	},
1283
1284	removeData: function( elem, name ) {
1285	elem = elem == window ?
1286	windowData :
1287	elem;
1288
1289	var id = elem[ expando ];
1290
1291	// If we want to remove a specific section of the element's data
1292	if ( name ) {
1293	if ( jQuery.cache[ id ] ) {
1294	// Remove the section of cache data
1295	delete jQuery.cache[ id ][ name ];
1296
1297	// If we've removed all the data, remove the element's cache
1298	name = "";
1299
1300	for ( name in jQuery.cache[ id ] )
1301	break;
1302
1303	if ( !name )
1304	jQuery.removeData( elem );
1305	}
1306
1307	// Otherwise, we want to remove all of the element's data
1308	} else {
1309	// Clean up the element expando
1310	try {
1311	delete elem[ expando ];
1312	} catch(e){
1313	// IE has trouble directly removing the expando
1314	// but it's ok with using removeAttribute
1315	if ( elem.removeAttribute )
1316	elem.removeAttribute( expando );
1317	}
1318
1319	// Completely remove the data cache
1320	delete jQuery.cache[ id ];
1321	}
1322	},
1323	queue: function( elem, type, data ) {
1324	if ( elem ){
1325
1326	type = (type \|\| "fx") + "queue";
1327
1328	var q = jQuery.data( elem, type );
1329
1330	if ( !q \|\| jQuery.isArray(data) )
1331	q = jQuery.data( elem, type, jQuery.makeArray(data) );
1332	else if( data )
1333	q.push( data );
1334
1335	}
1336	return q;
1337	},
1338
1339	dequeue: function( elem, type ){
1340	var queue = jQuery.queue( elem, type ),
1341	fn = queue.shift();
1342
1343	if( !type \|\| type === "fx" )
1344	fn = queue[0];
1345
1346	if( fn !== undefined )
1347	fn.call(elem);
1348	}
1349	});
1350
1351	jQuery.fn.extend({
1352	data: function( key, value ){
1353	var parts = key.split(".");
1354	parts[1] = parts[1] ? "." + parts[1] : "";
1355
1356	if ( value === undefined ) {
1357	var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1358
1359	if ( data === undefined && this.length )
1360	data = jQuery.data( this[0], key );
1361
1362	return data === undefined && parts[1] ?
1363	this.data( parts[0] ) :
1364	data;
1365	} else
1366	return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
1367	jQuery.data( this, key, value );
1368	});
1369	},
1370
1371	removeData: function( key ){
1372	return this.each(function(){
1373	jQuery.removeData( this, key );
1374	});
1375	},
1376	queue: function(type, data){
1377	if ( typeof type !== "string" ) {
1378	data = type;
1379	type = "fx";
1380	}
1381
1382	if ( data === undefined )
1383	return jQuery.queue( this[0], type );
1384
1385	return this.each(function(){
1386	var queue = jQuery.queue( this, type, data );
1387
1388	if( type == "fx" && queue.length == 1 )
1389	queue[0].call(this);
1390	});
1391	},
1392	dequeue: function(type){
1393	return this.each(function(){
1394	jQuery.dequeue( this, type );
1395	});
1396	}
1397	});/*!
1398	* Sizzle CSS Selector Engine - v0.9.3
1399	* Copyright 2009, The Dojo Foundation
1400	* Released under the MIT, BSD, and GPL Licenses.
1401	* More information: http://sizzlejs.com/
1402	*/
1403	(function(){
1404
1405	var chunker = /((?:\((?:\([^()]+\)\|[^()]+)+\)\|\[(?:\[[^[\]]\]\|['"][^'"]+['"]\|[^[\]'"]+)+\]\|\\.\|[^ >+~,(\[]+)+\|[>+~])(\s,\s*)?/g,
1406	done = 0,
1407	toString = Object.prototype.toString;
1408
1409	var Sizzle = function(selector, context, results, seed) {
1410	results = results \|\| [];
1411	context = context \|\| document;
1412
1413	if ( context.nodeType !== 1 && context.nodeType !== 9 )
1414	return [];
1415
1416	if ( !selector \|\| typeof selector !== "string" ) {
1417	return results;
1418	}
1419
1420	var parts = [], m, set, checkSet, check, mode, extra, prune = true;
1421
1422	// Reset the position of the chunker regexp (start from head)
1423	chunker.lastIndex = 0;
1424
1425	while ( (m = chunker.exec(selector)) !== null ) {
1426	parts.push( m[1] );
1427
1428	if ( m[2] ) {
1429	extra = RegExp.rightContext;
1430	break;
1431	}
1432	}
1433
1434	if ( parts.length > 1 && origPOS.exec( selector ) ) {
1435	if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
1436	set = posProcess( parts[0] + parts[1], context );
1437	} else {
1438	set = Expr.relative[ parts[0] ] ?
1439	[ context ] :
1440	Sizzle( parts.shift(), context );
1441
1442	while ( parts.length ) {
1443	selector = parts.shift();
1444
1445	if ( Expr.relative[ selector ] )
1446	selector += parts.shift();
1447
1448	set = posProcess( selector, set );
1449	}
1450	}
1451	} else {
1452	var ret = seed ?
1453	{ expr: parts.pop(), set: makeArray(seed) } :
1454	Sizzle.find( parts.pop(), parts.length === 1 && context.parentNode ? context.parentNode : context, isXML(context) );
1455	set = Sizzle.filter( ret.expr, ret.set );
1456
1457	if ( parts.length > 0 ) {
1458	checkSet = makeArray(set);
1459	} else {
1460	prune = false;
1461	}
1462
1463	while ( parts.length ) {
1464	var cur = parts.pop(), pop = cur;
1465
1466	if ( !Expr.relative[ cur ] ) {
1467	cur = "";
1468	} else {
1469	pop = parts.pop();
1470	}
1471
1472	if ( pop == null ) {
1473	pop = context;
1474	}
1475
1476	Expr.relative[ cur ]( checkSet, pop, isXML(context) );
1477	}
1478	}
1479
1480	if ( !checkSet ) {
1481	checkSet = set;
1482	}
1483
1484	if ( !checkSet ) {
1485	throw "Syntax error, unrecognized expression: " + (cur \|\| selector);
1486	}
1487
1488	if ( toString.call(checkSet) === "[object Array]" ) {
1489	if ( !prune ) {
1490	results.push.apply( results, checkSet );
1491	} else if ( context.nodeType === 1 ) {
1492	for ( var i = 0; checkSet[i] != null; i++ ) {
1493	if ( checkSet[i] && (checkSet[i] === true \|\| checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
1494	results.push( set[i] );
1495	}
1496	}
1497	} else {
1498	for ( var i = 0; checkSet[i] != null; i++ ) {
1499	if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
1500	results.push( set[i] );
1501	}
1502	}
1503	}
1504	} else {
1505	makeArray( checkSet, results );
1506	}
1507
1508	if ( extra ) {
1509	Sizzle( extra, context, results, seed );
1510	}
1511
1512	return results;
1513	};
1514
1515	Sizzle.matches = function(expr, set){
1516	return Sizzle(expr, null, null, set);
1517	};
1518
1519	Sizzle.find = function(expr, context, isXML){
1520	var set, match;
1521
1522	if ( !expr ) {
1523	return [];
1524	}
1525
1526	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
1527	var type = Expr.order[i], match;
1528
1529	if ( (match = Expr.match[ type ].exec( expr )) ) {
1530	var left = RegExp.leftContext;
1531
1532	if ( left.substr( left.length - 1 ) !== "\\" ) {
1533	match[1] = (match[1] \|\| "").replace(/\\/g, "");
1534	set = Expr.find[ type ]( match, context, isXML );
1535	if ( set != null ) {
1536	expr = expr.replace( Expr.match[ type ], "" );
1537	break;
1538	}
1539	}
1540	}
1541	}
1542
1543	if ( !set ) {
1544	set = context.getElementsByTagName("*");
1545	}
1546
1547	return {set: set, expr: expr};
1548	};
1549
1550	Sizzle.filter = function(expr, set, inplace, not){
1551	var old = expr, result = [], curLoop = set, match, anyFound;
1552
1553	while ( expr && set.length ) {
1554	for ( var type in Expr.filter ) {
1555	if ( (match = Expr.match[ type ].exec( expr )) != null ) {
1556	var filter = Expr.filter[ type ], found, item;
1557	anyFound = false;
1558
1559	if ( curLoop == result ) {
1560	result = [];
1561	}
1562
1563	if ( Expr.preFilter[ type ] ) {
1564	match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not );
1565
1566	if ( !match ) {
1567	anyFound = found = true;
1568	} else if ( match === true ) {
1569	continue;
1570	}
1571	}
1572
1573	if ( match ) {
1574	for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
1575	if ( item ) {
1576	found = filter( item, match, i, curLoop );
1577	var pass = not ^ !!found;
1578
1579	if ( inplace && found != null ) {
1580	if ( pass ) {
1581	anyFound = true;
1582	} else {
1583	curLoop[i] = false;
1584	}
1585	} else if ( pass ) {
1586	result.push( item );
1587	anyFound = true;
1588	}
1589	}
1590	}
1591	}
1592
1593	if ( found !== undefined ) {
1594	if ( !inplace ) {
1595	curLoop = result;
1596	}
1597
1598	expr = expr.replace( Expr.match[ type ], "" );
1599
1600	if ( !anyFound ) {
1601	return [];
1602	}
1603
1604	break;
1605	}
1606	}
1607	}
1608
1609	expr = expr.replace(/\s,\s/, "");
1610
1611	// Improper expression
1612	if ( expr == old ) {
1613	if ( anyFound == null ) {
1614	throw "Syntax error, unrecognized expression: " + expr;
1615	} else {
1616	break;
1617	}
1618	}
1619
1620	old = expr;
1621	}
1622
1623	return curLoop;
1624	};
1625
1626	var Expr = Sizzle.selectors = {
1627	order: [ "ID", "NAME", "TAG" ],
1628	match: {
1629	ID: /#((?:[\w\u00c0-\uFFFF_-]\|\\.)+)/,
1630	CLASS: /\.((?:[\w\u00c0-\uFFFF_-]\|\\.)+)/,
1631	NAME: /\[name=['"]((?:[\w\u00c0-\uFFFF_-]\|\\.)+)['"]\]/,
1632	ATTR: /\[\s((?:[\w\u00c0-\uFFFF_-]\|\\.)+)\s(?:(\S?=)\s(['"])(.?)\3\|)\s\]/,
1633	TAG: /^((?:[\w\u00c0-\uFFFF\*_-]\|\\.)+)/,
1634	CHILD: /:(only\|nth\|last\|first)-child(?:\((even\|odd\|[\dn+-]*)\))?/,
1635	POS: /:(nth\|eq\|gt\|lt\|first\|last\|even\|odd)(?:\((\d*)\))?(?=[^-]\|$)/,
1636	PSEUDO: /:((?:[\w\u00c0-\uFFFF_-]\|\\.)+)(?:\((['"])((?:\([^\)]+\)\|[^\2\(\)])+)\2\))?/
1637	},
1638	attrMap: {
1639	"class": "className",
1640	"for": "htmlFor"
1641	},
1642	attrHandle: {
1643	href: function(elem){
1644	return elem.getAttribute("href");
1645	}
1646	},
1647	relative: {
1648	"+": function(checkSet, part){
1649	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
1650	var elem = checkSet[i];
1651	if ( elem ) {
1652	var cur = elem.previousSibling;
1653	while ( cur && cur.nodeType !== 1 ) {
1654	cur = cur.previousSibling;
1655	}
1656	checkSet[i] = typeof part === "string" ?
1657	cur \|\| false :
1658	cur === part;
1659	}
1660	}
1661
1662	if ( typeof part === "string" ) {
1663	Sizzle.filter( part, checkSet, true );
1664	}
1665	},
1666	">": function(checkSet, part, isXML){
1667	if ( typeof part === "string" && !/\W/.test(part) ) {
1668	part = isXML ? part : part.toUpperCase();
1669
1670	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
1671	var elem = checkSet[i];
1672	if ( elem ) {
1673	var parent = elem.parentNode;
1674	checkSet[i] = parent.nodeName === part ? parent : false;
1675	}
1676	}
1677	} else {
1678	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
1679	var elem = checkSet[i];
1680	if ( elem ) {
1681	checkSet[i] = typeof part === "string" ?
1682	elem.parentNode :
1683	elem.parentNode === part;
1684	}
1685	}
1686
1687	if ( typeof part === "string" ) {
1688	Sizzle.filter( part, checkSet, true );
1689	}
1690	}
1691	},
1692	"": function(checkSet, part, isXML){
1693	var doneName = "done" + (done++), checkFn = dirCheck;
1694
1695	if ( !part.match(/\W/) ) {
1696	var nodeCheck = part = isXML ? part : part.toUpperCase();
1697	checkFn = dirNodeCheck;
1698	}
1699
1700	checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
1701	},
1702	"~": function(checkSet, part, isXML){
1703	var doneName = "done" + (done++), checkFn = dirCheck;
1704
1705	if ( typeof part === "string" && !part.match(/\W/) ) {
1706	var nodeCheck = part = isXML ? part : part.toUpperCase();
1707	checkFn = dirNodeCheck;
1708	}
1709
1710	checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
1711	}
1712	},
1713	find: {
1714	ID: function(match, context, isXML){
1715	if ( typeof context.getElementById !== "undefined" && !isXML ) {
1716	var m = context.getElementById(match[1]);
1717	return m ? [m] : [];
1718	}
1719	},
1720	NAME: function(match, context, isXML){
1721	if ( typeof context.getElementsByName !== "undefined" && !isXML ) {
1722	return context.getElementsByName(match[1]);
1723	}
1724	},
1725	TAG: function(match, context){
1726	return context.getElementsByTagName(match[1]);
1727	}
1728	},
1729	preFilter: {
1730	CLASS: function(match, curLoop, inplace, result, not){
1731	match = " " + match[1].replace(/\\/g, "") + " ";
1732
1733	var elem;
1734	for ( var i = 0; (elem = curLoop[i]) != null; i++ ) {
1735	if ( elem ) {
1736	if ( not ^ (" " + elem.className + " ").indexOf(match) >= 0 ) {
1737	if ( !inplace )
1738	result.push( elem );
1739	} else if ( inplace ) {
1740	curLoop[i] = false;
1741	}
1742	}
1743	}
1744
1745	return false;
1746	},
1747	ID: function(match){
1748	return match[1].replace(/\\/g, "");
1749	},
1750	TAG: function(match, curLoop){
1751	for ( var i = 0; curLoop[i] === false; i++ ){}
1752	return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase();
1753	},
1754	CHILD: function(match){
1755	if ( match[1] == "nth" ) {
1756	// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
1757	var test = /(-?)(\d)n((?:\+\|-)?\d)/.exec(
1758	match[2] == "even" && "2n" \|\| match[2] == "odd" && "2n+1" \|\|
1759	!/\D/.test( match[2] ) && "0n+" + match[2] \|\| match[2]);
1760
1761	// calculate the numbers (first)n+(last) including if they are negative
1762	match[2] = (test[1] + (test[2] \|\| 1)) - 0;
1763	match[3] = test[3] - 0;
1764	}
1765
1766	// TODO: Move to normal caching system
1767	match[0] = "done" + (done++);
1768
1769	return match;
1770	},
1771	ATTR: function(match){
1772	var name = match[1].replace(/\\/g, "");
1773
1774	if ( Expr.attrMap[name] ) {
1775	match[1] = Expr.attrMap[name];
1776	}
1777
1778	if ( match[2] === "~=" ) {
1779	match[4] = " " + match[4] + " ";
1780	}
1781
1782	return match;
1783	},
1784	PSEUDO: function(match, curLoop, inplace, result, not){
1785	if ( match[1] === "not" ) {
1786	// If we're dealing with a complex expression, or a simple one
1787	if ( match[3].match(chunker).length > 1 ) {
1788	match[3] = Sizzle(match[3], null, null, curLoop);
1789	} else {
1790	var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
1791	if ( !inplace ) {
1792	result.push.apply( result, ret );
1793	}
1794	return false;
1795	}
1796	} else if ( Expr.match.POS.test( match[0] ) ) {
1797	return true;
1798	}
1799
1800	return match;
1801	},
1802	POS: function(match){
1803	match.unshift( true );
1804	return match;
1805	}
1806	},
1807	filters: {
1808	enabled: function(elem){
1809	return elem.disabled === false && elem.type !== "hidden";
1810	},
1811	disabled: function(elem){
1812	return elem.disabled === true;
1813	},
1814	checked: function(elem){
1815	return elem.checked === true;
1816	},
1817	selected: function(elem){
1818	// Accessing this property makes selected-by-default
1819	// options in Safari work properly
1820	elem.parentNode.selectedIndex;
1821	return elem.selected === true;
1822	},
1823	parent: function(elem){
1824	return !!elem.firstChild;
1825	},
1826	empty: function(elem){
1827	return !elem.firstChild;
1828	},
1829	has: function(elem, i, match){
1830	return !!Sizzle( match[3], elem ).length;
1831	},
1832	header: function(elem){
1833	return /h\d/i.test( elem.nodeName );
1834	},
1835	text: function(elem){
1836	return "text" === elem.type;
1837	},
1838	radio: function(elem){
1839	return "radio" === elem.type;
1840	},
1841	checkbox: function(elem){
1842	return "checkbox" === elem.type;
1843	},
1844	file: function(elem){
1845	return "file" === elem.type;
1846	},
1847	password: function(elem){
1848	return "password" === elem.type;
1849	},
1850	submit: function(elem){
1851	return "submit" === elem.type;
1852	},
1853	image: function(elem){
1854	return "image" === elem.type;
1855	},
1856	reset: function(elem){
1857	return "reset" === elem.type;
1858	},
1859	button: function(elem){
1860	return "button" === elem.type \|\| elem.nodeName.toUpperCase() === "BUTTON";
1861	},
1862	input: function(elem){
1863	return /input\|select\|textarea\|button/i.test(elem.nodeName);
1864	}
1865	},
1866	setFilters: {
1867	first: function(elem, i){
1868	return i === 0;
1869	},
1870	last: function(elem, i, match, array){
1871	return i === array.length - 1;
1872	},
1873	even: function(elem, i){
1874	return i % 2 === 0;
1875	},
1876	odd: function(elem, i){
1877	return i % 2 === 1;
1878	},
1879	lt: function(elem, i, match){
1880	return i < match[3] - 0;
1881	},
1882	gt: function(elem, i, match){
1883	return i > match[3] - 0;
1884	},
1885	nth: function(elem, i, match){
1886	return match[3] - 0 == i;
1887	},
1888	eq: function(elem, i, match){
1889	return match[3] - 0 == i;
1890	}
1891	},
1892	filter: {
1893	CHILD: function(elem, match){
1894	var type = match[1], parent = elem.parentNode;
1895
1896	var doneName = match[0];
1897
1898	if ( parent && (!parent[ doneName ] \|\| !elem.nodeIndex) ) {
1899	var count = 1;
1900
1901	for ( var node = parent.firstChild; node; node = node.nextSibling ) {
1902	if ( node.nodeType == 1 ) {
1903	node.nodeIndex = count++;
1904	}
1905	}
1906
1907	parent[ doneName ] = count - 1;
1908	}
1909
1910	if ( type == "first" ) {
1911	return elem.nodeIndex == 1;
1912	} else if ( type == "last" ) {
1913	return elem.nodeIndex == parent[ doneName ];
1914	} else if ( type == "only" ) {
1915	return parent[ doneName ] == 1;
1916	} else if ( type == "nth" ) {
1917	var add = false, first = match[2], last = match[3];
1918
1919	if ( first == 1 && last == 0 ) {
1920	return true;
1921	}
1922
1923	if ( first == 0 ) {
1924	if ( elem.nodeIndex == last ) {
1925	add = true;
1926	}
1927	} else if ( (elem.nodeIndex - last) % first == 0 && (elem.nodeIndex - last) / first >= 0 ) {
1928	add = true;
1929	}
1930
1931	return add;
1932	}
1933	},
1934	PSEUDO: function(elem, match, i, array){
1935	var name = match[1], filter = Expr.filters[ name ];
1936
1937	if ( filter ) {
1938	return filter( elem, i, match, array );
1939	} else if ( name === "contains" ) {
1940	return (elem.textContent \|\| elem.innerText \|\| "").indexOf(match[3]) >= 0;
1941	} else if ( name === "not" ) {
1942	var not = match[3];
1943
1944	for ( var i = 0, l = not.length; i < l; i++ ) {
1945	if ( not[i] === elem ) {
1946	return false;
1947	}
1948	}
1949
1950	return true;
1951	}
1952	},
1953	ID: function(elem, match){
1954	return elem.nodeType === 1 && elem.getAttribute("id") === match;
1955	},
1956	TAG: function(elem, match){
1957	return (match === "*" && elem.nodeType === 1) \|\| elem.nodeName === match;
1958	},
1959	CLASS: function(elem, match){
1960	return match.test( elem.className );
1961	},
1962	ATTR: function(elem, match){
1963	var result = Expr.attrHandle[ match[1] ] ? Expr.attrHandle[ match[1] ]( elem ) : elem[ match[1] ] \|\| elem.getAttribute( match[1] ), value = result + "", type = match[2], check = match[4];
1964	return result == null ?
1965	type === "!=" :
1966	type === "=" ?
1967	value === check :
1968	type === "*=" ?
1969	value.indexOf(check) >= 0 :
1970	type === "~=" ?
1971	(" " + value + " ").indexOf(check) >= 0 :
1972	!match[4] ?
1973	result :
1974	type === "!=" ?
1975	value != check :
1976	type === "^=" ?
1977	value.indexOf(check) === 0 :
1978	type === "$=" ?
1979	value.substr(value.length - check.length) === check :
1980	type === "\|=" ?
1981	value === check \|\| value.substr(0, check.length + 1) === check + "-" :
1982	false;
1983	},
1984	POS: function(elem, match, i, array){
1985	var name = match[2], filter = Expr.setFilters[ name ];
1986
1987	if ( filter ) {
1988	return filter( elem, i, match, array );
1989	}
1990	}
1991	}
1992	};
1993
1994	var origPOS = Expr.match.POS;
1995
1996	for ( var type in Expr.match ) {
1997	Expr.match[ type ] = RegExp( Expr.match[ type ].source + /(?![^\[]\])(?![^\(]\))/.source );
1998	}
1999
2000	var makeArray = function(array, results) {
2001	array = Array.prototype.slice.call( array );
2002
2003	if ( results ) {
2004	results.push.apply( results, array );
2005	return results;
2006	}
2007
2008	return array;
2009	};
2010
2011	// Perform a simple check to determine if the browser is capable of
2012	// converting a NodeList to an array using builtin methods.
2013	try {
2014	Array.prototype.slice.call( document.documentElement.childNodes );
2015
2016	// Provide a fallback method if it does not work
2017	} catch(e){
2018	makeArray = function(array, results) {
2019	var ret = results \|\| [];
2020
2021	if ( toString.call(array) === "[object Array]" ) {
2022	Array.prototype.push.apply( ret, array );
2023	} else {
2024	if ( typeof array.length === "number" ) {
2025	for ( var i = 0, l = array.length; i < l; i++ ) {
2026	ret.push( array[i] );
2027	}
2028	} else {
2029	for ( var i = 0; array[i]; i++ ) {
2030	ret.push( array[i] );
2031	}
2032	}
2033	}
2034
2035	return ret;
2036	};
2037	}
2038
2039	// Check to see if the browser returns elements by name when
2040	// querying by getElementById (and provide a workaround)
2041	(function(){
2042	// We're going to inject a fake input element with a specified name
2043	var form = document.createElement("form"),
2044	id = "script" + (new Date).getTime();
2045	form.innerHTML = "<input name='" + id + "'/>";
2046
2047	// Inject it into the root element, check its status, and remove it quickly
2048	var root = document.documentElement;
2049	root.insertBefore( form, root.firstChild );
2050
2051	// The workaround has to do additional checks after a getElementById
2052	// Which slows things down for other browsers (hence the branching)
2053	if ( !!document.getElementById( id ) ) {
2054	Expr.find.ID = function(match, context, isXML){
2055	if ( typeof context.getElementById !== "undefined" && !isXML ) {
2056	var m = context.getElementById(match[1]);
2057	return m ? m.id === match[1] \|\| typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
2058	}
2059	};
2060
2061	Expr.filter.ID = function(elem, match){
2062	var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
2063	return elem.nodeType === 1 && node && node.nodeValue === match;
2064	};
2065	}
2066
2067	root.removeChild( form );
2068	})();
2069
2070	(function(){
2071	// Check to see if the browser returns only elements
2072	// when doing getElementsByTagName("*")
2073
2074	// Create a fake element
2075	var div = document.createElement("div");
2076	div.appendChild( document.createComment("") );
2077
2078	// Make sure no comments are found
2079	if ( div.getElementsByTagName("*").length > 0 ) {
2080	Expr.find.TAG = function(match, context){
2081	var results = context.getElementsByTagName(match[1]);
2082
2083	// Filter out possible comments
2084	if ( match[1] === "*" ) {
2085	var tmp = [];
2086
2087	for ( var i = 0; results[i]; i++ ) {
2088	if ( results[i].nodeType === 1 ) {
2089	tmp.push( results[i] );
2090	}
2091	}
2092
2093	results = tmp;
2094	}
2095
2096	return results;
2097	};
2098	}
2099
2100	// Check to see if an attribute returns normalized href attributes
2101	div.innerHTML = "<a href='#'></a>";
2102	if ( div.firstChild && div.firstChild.getAttribute("href") !== "#" ) {
2103	Expr.attrHandle.href = function(elem){
2104	return elem.getAttribute("href", 2);
2105	};
2106	}
2107	})();
2108
2109	if ( document.querySelectorAll ) (function(){
2110	var oldSizzle = Sizzle, div = document.createElement("div");
2111	div.innerHTML = "<p class='TEST'></p>";
2112
2113	// Safari can't handle uppercase or unicode characters when
2114	// in quirks mode.
2115	if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
2116	return;
2117	}
2118
2119	Sizzle = function(query, context, extra, seed){
2120	context = context \|\| document;
2121
2122	// Only use querySelectorAll on non-XML documents
2123	// (ID selectors don't work in non-HTML documents)
2124	if ( !seed && context.nodeType === 9 && !isXML(context) ) {
2125	try {
2126	return makeArray( context.querySelectorAll(query), extra );
2127	} catch(e){}
2128	}
2129
2130	return oldSizzle(query, context, extra, seed);
2131	};
2132
2133	Sizzle.find = oldSizzle.find;
2134	Sizzle.filter = oldSizzle.filter;
2135	Sizzle.selectors = oldSizzle.selectors;
2136	Sizzle.matches = oldSizzle.matches;
2137	})();
2138
2139	if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) {
2140	Expr.order.splice(1, 0, "CLASS");
2141	Expr.find.CLASS = function(match, context) {
2142	return context.getElementsByClassName(match[1]);
2143	};
2144	}
2145
2146	function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
2147	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2148	var elem = checkSet[i];
2149	if ( elem ) {
2150	elem = elem[dir];
2151	var match = false;
2152
2153	while ( elem && elem.nodeType ) {
2154	var done = elem[doneName];
2155	if ( done ) {
2156	match = checkSet[ done ];
2157	break;
2158	}
2159
2160	if ( elem.nodeType === 1 && !isXML )
2161	elem[doneName] = i;
2162
2163	if ( elem.nodeName === cur ) {
2164	match = elem;
2165	break;
2166	}
2167
2168	elem = elem[dir];
2169	}
2170
2171	checkSet[i] = match;
2172	}
2173	}
2174	}
2175
2176	function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
2177	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2178	var elem = checkSet[i];
2179	if ( elem ) {
2180	elem = elem[dir];
2181	var match = false;
2182
2183	while ( elem && elem.nodeType ) {
2184	if ( elem[doneName] ) {
2185	match = checkSet[ elem[doneName] ];
2186	break;
2187	}
2188
2189	if ( elem.nodeType === 1 ) {
2190	if ( !isXML )
2191	elem[doneName] = i;
2192
2193	if ( typeof cur !== "string" ) {
2194	if ( elem === cur ) {
2195	match = true;
2196	break;
2197	}
2198
2199	} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
2200	match = elem;
2201	break;
2202	}
2203	}
2204
2205	elem = elem[dir];
2206	}
2207
2208	checkSet[i] = match;
2209	}
2210	}
2211	}
2212
2213	var contains = document.compareDocumentPosition ? function(a, b){
2214	return a.compareDocumentPosition(b) & 16;
2215	} : function(a, b){
2216	return a !== b && (a.contains ? a.contains(b) : true);
2217	};
2218
2219	var isXML = function(elem){
2220	return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" \|\|
2221	!!elem.ownerDocument && isXML( elem.ownerDocument );
2222	};
2223
2224	var posProcess = function(selector, context){
2225	var tmpSet = [], later = "", match,
2226	root = context.nodeType ? [context] : context;
2227
2228	// Position selectors must be done after the filter
2229	// And so must :not(positional) so we move all PSEUDOs to the end
2230	while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
2231	later += match[0];
2232	selector = selector.replace( Expr.match.PSEUDO, "" );
2233	}
2234
2235	selector = Expr.relative[selector] ? selector + "*" : selector;
2236
2237	for ( var i = 0, l = root.length; i < l; i++ ) {
2238	Sizzle( selector, root[i], tmpSet );
2239	}
2240
2241	return Sizzle.filter( later, tmpSet );
2242	};
2243
2244	// EXPOSE
2245	jQuery.find = Sizzle;
2246	jQuery.filter = Sizzle.filter;
2247	jQuery.expr = Sizzle.selectors;
2248	jQuery.expr[":"] = jQuery.expr.filters;
2249
2250	Sizzle.selectors.filters.hidden = function(elem){
2251	return "hidden" === elem.type \|\|
2252	jQuery.css(elem, "display") === "none" \|\|
2253	jQuery.css(elem, "visibility") === "hidden";
2254	};
2255
2256	Sizzle.selectors.filters.visible = function(elem){
2257	return "hidden" !== elem.type &&
2258	jQuery.css(elem, "display") !== "none" &&
2259	jQuery.css(elem, "visibility") !== "hidden";
2260	};
2261
2262	Sizzle.selectors.filters.animated = function(elem){
2263	return jQuery.grep(jQuery.timers, function(fn){
2264	return elem === fn.elem;
2265	}).length;
2266	};
2267
2268	jQuery.multiFilter = function( expr, elems, not ) {
2269	if ( not ) {
2270	expr = ":not(" + expr + ")";
2271	}
2272
2273	return Sizzle.matches(expr, elems);
2274	};
2275
2276	jQuery.dir = function( elem, dir ){
2277	var matched = [], cur = elem[dir];
2278	while ( cur && cur != document ) {
2279	if ( cur.nodeType == 1 )
2280	matched.push( cur );
2281	cur = cur[dir];
2282	}
2283	return matched;
2284	};
2285
2286	jQuery.nth = function(cur, result, dir, elem){
2287	result = result \|\| 1;
2288	var num = 0;
2289
2290	for ( ; cur; cur = cur[dir] )
2291	if ( cur.nodeType == 1 && ++num == result )
2292	break;
2293
2294	return cur;
2295	};
2296
2297	jQuery.sibling = function(n, elem){
2298	var r = [];
2299
2300	for ( ; n; n = n.nextSibling ) {
2301	if ( n.nodeType == 1 && n != elem )
2302	r.push( n );
2303	}
2304
2305	return r;
2306	};
2307
2308	return;
2309
2310	window.Sizzle = Sizzle;
2311
2312	})();
2313	/*
2314	* A number of helper functions used for managing events.
2315	* Many of the ideas behind this code originated from
2316	* Dean Edwards' addEvent library.
2317	*/
2318	jQuery.event = {
2319
2320	// Bind an event to an element
2321	// Original by Dean Edwards
2322	add: function(elem, types, handler, data) {
2323	if ( elem.nodeType == 3 \|\| elem.nodeType == 8 )
2324	return;
2325
2326	// For whatever reason, IE has trouble passing the window object
2327	// around, causing it to be cloned in the process
2328	if ( elem.setInterval && elem != window )
2329	elem = window;
2330
2331	// Make sure that the function being executed has a unique ID
2332	if ( !handler.guid )
2333	handler.guid = this.guid++;
2334
2335	// if data is passed, bind to handler
2336	if ( data !== undefined ) {
2337	// Create temporary function pointer to original handler
2338	var fn = handler;
2339
2340	// Create unique handler function, wrapped around original handler
2341	handler = this.proxy( fn );
2342
2343	// Store data in unique handler
2344	handler.data = data;
2345	}
2346
2347	// Init the element's event structure
2348	var events = jQuery.data(elem, "events") \|\| jQuery.data(elem, "events", {}),
2349	handle = jQuery.data(elem, "handle") \|\| jQuery.data(elem, "handle", function(){
2350	// Handle the second event of a trigger and when
2351	// an event is called after a page has unloaded
2352	return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
2353	jQuery.event.handle.apply(arguments.callee.elem, arguments) :
2354	undefined;
2355	});
2356	// Add elem as a property of the handle function
2357	// This is to prevent a memory leak with non-native
2358	// event in IE.
2359	handle.elem = elem;
2360
2361	// Handle multiple events separated by a space
2362	// jQuery(...).bind("mouseover mouseout", fn);
2363	jQuery.each(types.split(/\s+/), function(index, type) {
2364	// Namespaced event handlers
2365	var namespaces = type.split(".");
2366	type = namespaces.shift();
2367	handler.type = namespaces.slice().sort().join(".");
2368
2369	// Get the current list of functions bound to this event
2370	var handlers = events[type];
2371
2372	if ( jQuery.event.specialAll[type] )
2373	jQuery.event.specialAll[type].setup.call(elem, data, namespaces);
2374
2375	// Init the event handler queue
2376	if (!handlers) {
2377	handlers = events[type] = {};
2378
2379	// Check for a special event handler
2380	// Only use addEventListener/attachEvent if the special
2381	// events handler returns false
2382	if ( !jQuery.event.special[type] \|\| jQuery.event.special[type].setup.call(elem, data, namespaces) === false ) {
2383	// Bind the global event handler to the element
2384	if (elem.addEventListener)
2385	elem.addEventListener(type, handle, false);
2386	else if (elem.attachEvent)
2387	elem.attachEvent("on" + type, handle);
2388	}
2389	}
2390
2391	// Add the function to the element's handler list
2392	handlers[handler.guid] = handler;
2393
2394	// Keep track of which events have been used, for global triggering
2395	jQuery.event.global[type] = true;
2396	});
2397
2398	// Nullify elem to prevent memory leaks in IE
2399	elem = null;
2400	},
2401
2402	guid: 1,
2403	global: {},
2404
2405	// Detach an event or set of events from an element
2406	remove: function(elem, types, handler) {
2407	// don't do events on text and comment nodes
2408	if ( elem.nodeType == 3 \|\| elem.nodeType == 8 )
2409	return;
2410
2411	var events = jQuery.data(elem, "events"), ret, index;
2412
2413	if ( events ) {
2414	// Unbind all events for the element
2415	if ( types === undefined \|\| (typeof types === "string" && types.charAt(0) == ".") )
2416	for ( var type in events )
2417	this.remove( elem, type + (types \|\| "") );
2418	else {
2419	// types is actually an event object here
2420	if ( types.type ) {
2421	handler = types.handler;
2422	types = types.type;
2423	}
2424
2425	// Handle multiple events seperated by a space
2426	// jQuery(...).unbind("mouseover mouseout", fn);
2427	jQuery.each(types.split(/\s+/), function(index, type){
2428	// Namespaced event handlers
2429	var namespaces = type.split(".");
2430	type = namespaces.shift();
2431	var namespace = RegExp("(^\|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.\|$)");
2432
2433	if ( events[type] ) {
2434	// remove the given handler for the given type
2435	if ( handler )
2436	delete events[type][handler.guid];
2437
2438	// remove all handlers for the given type
2439	else
2440	for ( var handle in events[type] )
2441	// Handle the removal of namespaced events
2442	if ( namespace.test(events[type][handle].type) )
2443	delete events[type][handle];
2444
2445	if ( jQuery.event.specialAll[type] )
2446	jQuery.event.specialAll[type].teardown.call(elem, namespaces);
2447
2448	// remove generic event handler if no more handlers exist
2449	for ( ret in events[type] ) break;
2450	if ( !ret ) {
2451	if ( !jQuery.event.special[type] \|\| jQuery.event.special[type].teardown.call(elem, namespaces) === false ) {
2452	if (elem.removeEventListener)
2453	elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
2454	else if (elem.detachEvent)
2455	elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
2456	}
2457	ret = null;
2458	delete events[type];
2459	}
2460	}
2461	});
2462	}
2463
2464	// Remove the expando if it's no longer used
2465	for ( ret in events ) break;
2466	if ( !ret ) {
2467	var handle = jQuery.data( elem, "handle" );
2468	if ( handle ) handle.elem = null;
2469	jQuery.removeData( elem, "events" );
2470	jQuery.removeData( elem, "handle" );
2471	}
2472	}
2473	},
2474
2475	// bubbling is internal
2476	trigger: function( event, data, elem, bubbling ) {
2477	// Event object or event type
2478	var type = event.type \|\| event;
2479
2480	if( !bubbling ){
2481	event = typeof event === "object" ?
2482	// jQuery.Event object
2483	event[expando] ? event :
2484	// Object literal
2485	jQuery.extend( jQuery.Event(type), event ) :
2486	// Just the event type (string)
2487	jQuery.Event(type);
2488
2489	if ( type.indexOf("!") >= 0 ) {
2490	event.type = type = type.slice(0, -1);
2491	event.exclusive = true;
2492	}
2493
2494	// Handle a global trigger
2495	if ( !elem ) {
2496	// Don't bubble custom events when global (to avoid too much overhead)
2497	event.stopPropagation();
2498	// Only trigger if we've ever bound an event for it
2499	if ( this.global[type] )
2500	jQuery.each( jQuery.cache, function(){
2501	if ( this.events && this.events[type] )
2502	jQuery.event.trigger( event, data, this.handle.elem );
2503	});
2504	}
2505
2506	// Handle triggering a single element
2507
2508	// don't do events on text and comment nodes
2509	if ( !elem \|\| elem.nodeType == 3 \|\| elem.nodeType == 8 )
2510	return undefined;
2511
2512	// Clean up in case it is reused
2513	event.result = undefined;
2514	event.target = elem;
2515
2516	// Clone the incoming data, if any
2517	data = jQuery.makeArray(data);
2518	data.unshift( event );
2519	}
2520
2521	event.currentTarget = elem;
2522
2523	// Trigger the event, it is assumed that "handle" is a function
2524	var handle = jQuery.data(elem, "handle");
2525	if ( handle )
2526	handle.apply( elem, data );
2527
2528	// Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
2529	if ( (!elem[type] \|\| (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
2530	event.result = false;
2531
2532	// Trigger the native events (except for clicks on links)
2533	if ( !bubbling && elem[type] && !event.isDefaultPrevented() && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
2534	this.triggered = true;
2535	try {
2536	elem[ type ]();
2537	// prevent IE from throwing an error for some hidden elements
2538	} catch (e) {}
2539	}
2540
2541	this.triggered = false;
2542
2543	if ( !event.isPropagationStopped() ) {
2544	var parent = elem.parentNode \|\| elem.ownerDocument;
2545	if ( parent )
2546	jQuery.event.trigger(event, data, parent, true);
2547	}
2548	},
2549
2550	handle: function(event) {
2551	// returned undefined or false
2552	var all, handlers;
2553
2554	event = arguments[0] = jQuery.event.fix( event \|\| window.event );
2555
2556	// Namespaced event handlers
2557	var namespaces = event.type.split(".");
2558	event.type = namespaces.shift();
2559
2560	// Cache this now, all = true means, any handler
2561	all = !namespaces.length && !event.exclusive;
2562
2563	var namespace = RegExp("(^\|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.\|$)");
2564
2565	handlers = ( jQuery.data(this, "events") \|\| {} )[event.type];
2566
2567	for ( var j in handlers ) {
2568	var handler = handlers[j];
2569
2570	// Filter the functions by class
2571	if ( all \|\| namespace.test(handler.type) ) {
2572	// Pass in a reference to the handler function itself
2573	// So that we can later remove it
2574	event.handler = handler;
2575	event.data = handler.data;
2576
2577	var ret = handler.apply(this, arguments);
2578
2579	if( ret !== undefined ){
2580	event.result = ret;
2581	if ( ret === false ) {
2582	event.preventDefault();
2583	event.stopPropagation();
2584	}
2585	}
2586
2587	if( event.isImmediatePropagationStopped() )
2588	break;
2589
2590	}
2591	}
2592	},
2593
2594	props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
2595
2596	fix: function(event) {
2597	if ( event[expando] )
2598	return event;
2599
2600	// store a copy of the original event object
2601	// and "clone" to set read-only properties
2602	var originalEvent = event;
2603	event = jQuery.Event( originalEvent );
2604
2605	for ( var i = this.props.length, prop; i; ){
2606	prop = this.props[ --i ];
2607	event[ prop ] = originalEvent[ prop ];
2608	}
2609
2610	// Fix target property, if necessary
2611	if ( !event.target )
2612	event.target = event.srcElement \|\| document; // Fixes #1925 where srcElement might not be defined either
2613
2614	// check if target is a textnode (safari)
2615	if ( event.target.nodeType == 3 )
2616	event.target = event.target.parentNode;
2617
2618	// Add relatedTarget, if necessary
2619	if ( !event.relatedTarget && event.fromElement )
2620	event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
2621
2622	// Calculate pageX/Y if missing and clientX/Y available
2623	if ( event.pageX == null && event.clientX != null ) {
2624	var doc = document.documentElement, body = document.body;
2625	event.pageX = event.clientX + (doc && doc.scrollLeft \|\| body && body.scrollLeft \|\| 0) - (doc.clientLeft \|\| 0);
2626	event.pageY = event.clientY + (doc && doc.scrollTop \|\| body && body.scrollTop \|\| 0) - (doc.clientTop \|\| 0);
2627	}
2628
2629	// Add which for key events
2630	if ( !event.which && ((event.charCode \|\| event.charCode === 0) ? event.charCode : event.keyCode) )
2631	event.which = event.charCode \|\| event.keyCode;
2632
2633	// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2634	if ( !event.metaKey && event.ctrlKey )
2635	event.metaKey = event.ctrlKey;
2636
2637	// Add which for click: 1 == left; 2 == middle; 3 == right
2638	// Note: button is not normalized, so don't use it
2639	if ( !event.which && event.button )
2640	event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2641
2642	return event;
2643	},
2644
2645	proxy: function( fn, proxy ){
2646	proxy = proxy \|\| function(){ return fn.apply(this, arguments); };
2647	// Set the guid of unique handler to the same of original handler, so it can be removed
2648	proxy.guid = fn.guid = fn.guid \|\| proxy.guid \|\| this.guid++;
2649	// So proxy can be declared as an argument
2650	return proxy;
2651	},
2652
2653	special: {
2654	ready: {
2655	// Make sure the ready event is setup
2656	setup: bindReady,
2657	teardown: function() {}
2658	}
2659	},
2660
2661	specialAll: {
2662	live: {
2663	setup: function( selector, namespaces ){
2664	jQuery.event.add( this, namespaces[0], liveHandler );
2665	},
2666	teardown: function( namespaces ){
2667	if ( namespaces.length ) {
2668	var remove = 0, name = RegExp("(^\|\\.)" + namespaces[0] + "(\\.\|$)");
2669
2670	jQuery.each( (jQuery.data(this, "events").live \|\| {}), function(){
2671	if ( name.test(this.type) )
2672	remove++;
2673	});
2674
2675	if ( remove < 1 )
2676	jQuery.event.remove( this, namespaces[0], liveHandler );
2677	}
2678	}
2679	}
2680	}
2681	};
2682
2683	jQuery.Event = function( src ){
2684	// Allow instantiation without the 'new' keyword
2685	if( !this.preventDefault )
2686	return new jQuery.Event(src);
2687
2688	// Event object
2689	if( src && src.type ){
2690	this.originalEvent = src;
2691	this.type = src.type;
2692	// Event type
2693	}else
2694	this.type = src;
2695
2696	// timeStamp is buggy for some events on Firefox(#3843)
2697	// So we won't rely on the native value
2698	this.timeStamp = now();
2699
2700	// Mark it as fixed
2701	this[expando] = true;
2702	};
2703
2704	function returnFalse(){
2705	return false;
2706	}
2707	function returnTrue(){
2708	return true;
2709	}
2710
2711	// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
2712	// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
2713	jQuery.Event.prototype = {
2714	preventDefault: function() {
2715	this.isDefaultPrevented = returnTrue;
2716
2717	var e = this.originalEvent;
2718	if( !e )
2719	return;
2720	// if preventDefault exists run it on the original event
2721	if (e.preventDefault)
2722	e.preventDefault();
2723	// otherwise set the returnValue property of the original event to false (IE)
2724	e.returnValue = false;
2725	},
2726	stopPropagation: function() {
2727	this.isPropagationStopped = returnTrue;
2728
2729	var e = this.originalEvent;
2730	if( !e )
2731	return;
2732	// if stopPropagation exists run it on the original event
2733	if (e.stopPropagation)
2734	e.stopPropagation();
2735	// otherwise set the cancelBubble property of the original event to true (IE)
2736	e.cancelBubble = true;
2737	},
2738	stopImmediatePropagation:function(){
2739	this.isImmediatePropagationStopped = returnTrue;
2740	this.stopPropagation();
2741	},
2742	isDefaultPrevented: returnFalse,
2743	isPropagationStopped: returnFalse,
2744	isImmediatePropagationStopped: returnFalse
2745	};
2746	// Checks if an event happened on an element within another element
2747	// Used in jQuery.event.special.mouseenter and mouseleave handlers
2748	var withinElement = function(event) {
2749	// Check if mouse(over\|out) are still within the same parent element
2750	var parent = event.relatedTarget;
2751	// Traverse up the tree
2752	while ( parent && parent != this )
2753	try { parent = parent.parentNode; }
2754	catch(e) { parent = this; }
2755
2756	if( parent != this ){
2757	// set the correct event type
2758	event.type = event.data;
2759	// handle event if we actually just moused on to a non sub-element
2760	jQuery.event.handle.apply( this, arguments );
2761	}
2762	};
2763
2764	jQuery.each({
2765	mouseover: 'mouseenter',
2766	mouseout: 'mouseleave'
2767	}, function( orig, fix ){
2768	jQuery.event.special[ fix ] = {
2769	setup: function(){
2770	jQuery.event.add( this, orig, withinElement, fix );
2771	},
2772	teardown: function(){
2773	jQuery.event.remove( this, orig, withinElement );
2774	}
2775	};
2776	});
2777
2778	jQuery.fn.extend({
2779	bind: function( type, data, fn ) {
2780	return type == "unload" ? this.one(type, data, fn) : this.each(function(){
2781	jQuery.event.add( this, type, fn \|\| data, fn && data );
2782	});
2783	},
2784
2785	one: function( type, data, fn ) {
2786	var one = jQuery.event.proxy( fn \|\| data, function(event) {
2787	jQuery(this).unbind(event, one);
2788	return (fn \|\| data).apply( this, arguments );
2789	});
2790	return this.each(function(){
2791	jQuery.event.add( this, type, one, fn && data);
2792	});
2793	},
2794
2795	unbind: function( type, fn ) {
2796	return this.each(function(){
2797	jQuery.event.remove( this, type, fn );
2798	});
2799	},
2800
2801	trigger: function( type, data ) {
2802	return this.each(function(){
2803	jQuery.event.trigger( type, data, this );
2804	});
2805	},
2806
2807	triggerHandler: function( type, data ) {
2808	if( this[0] ){
2809	var event = jQuery.Event(type);
2810	event.preventDefault();
2811	event.stopPropagation();
2812	jQuery.event.trigger( event, data, this[0] );
2813	return event.result;
2814	}
2815	},
2816
2817	toggle: function( fn ) {
2818	// Save reference to arguments for access in closure
2819	var args = arguments, i = 1;
2820
2821	// link all the functions, so any of them can unbind this click handler
2822	while( i < args.length )
2823	jQuery.event.proxy( fn, args[i++] );
2824
2825	return this.click( jQuery.event.proxy( fn, function(event) {
2826	// Figure out which function to execute
2827	this.lastToggle = ( this.lastToggle \|\| 0 ) % i;
2828
2829	// Make sure that clicks stop
2830	event.preventDefault();
2831
2832	// and execute the function
2833	return args[ this.lastToggle++ ].apply( this, arguments ) \|\| false;
2834	}));
2835	},
2836
2837	hover: function(fnOver, fnOut) {
2838	return this.mouseenter(fnOver).mouseleave(fnOut);
2839	},
2840
2841	ready: function(fn) {
2842	// Attach the listeners
2843	bindReady();
2844
2845	// If the DOM is already ready
2846	if ( jQuery.isReady )
2847	// Execute the function immediately
2848	fn.call( document, jQuery );
2849
2850	// Otherwise, remember the function for later
2851	else
2852	// Add the function to the wait list
2853	jQuery.readyList.push( fn );
2854
2855	return this;
2856	},
2857
2858	live: function( type, fn ){
2859	var proxy = jQuery.event.proxy( fn );
2860	proxy.guid += this.selector + type;
2861
2862	jQuery(document).bind( liveConvert(type, this.selector), this.selector, proxy );
2863
2864	return this;
2865	},
2866
2867	die: function( type, fn ){
2868	jQuery(document).unbind( liveConvert(type, this.selector), fn ? { guid: fn.guid + this.selector + type } : null );
2869	return this;
2870	}
2871	});
2872
2873	function liveHandler( event ){
2874	var check = RegExp("(^\|\\.)" + event.type + "(\\.\|$)"),
2875	stop = true,
2876	elems = [];
2877
2878	jQuery.each(jQuery.data(this, "events").live \|\| [], function(i, fn){
2879	if ( check.test(fn.type) ) {
2880	var elem = jQuery(event.target).closest(fn.data)[0];
2881	if ( elem )
2882	elems.push({ elem: elem, fn: fn });
2883	}
2884	});
2885
2886	jQuery.each(elems, function(){
2887	if ( this.fn.call(this.elem, event, this.fn.data) === false )
2888	stop = false;
2889	});
2890
2891	return stop;
2892	}
2893
2894	function liveConvert(type, selector){
2895	return ["live", type, selector.replace(/\./g, "`").replace(/ /g, "\|")].join(".");
2896	}
2897
2898	jQuery.extend({
2899	isReady: false,
2900	readyList: [],
2901	// Handle when the DOM is ready
2902	ready: function() {
2903	// Make sure that the DOM is not already loaded
2904	if ( !jQuery.isReady ) {
2905	// Remember that the DOM is ready
2906	jQuery.isReady = true;
2907
2908	// If there are functions bound, to execute
2909	if ( jQuery.readyList ) {
2910	// Execute all of them
2911	jQuery.each( jQuery.readyList, function(){
2912	this.call( document, jQuery );
2913	});
2914
2915	// Reset the list of functions
2916	jQuery.readyList = null;
2917	}
2918
2919	// Trigger any bound ready events
2920	jQuery(document).triggerHandler("ready");
2921	}
2922	}
2923	});
2924
2925	var readyBound = false;
2926
2927	function bindReady(){
2928	if ( readyBound ) return;
2929	readyBound = true;
2930
2931	// Mozilla, Opera and webkit nightlies currently support this event
2932	if ( document.addEventListener ) {
2933	// Use the handy event callback
2934	document.addEventListener( "DOMContentLoaded", function(){
2935	document.removeEventListener( "DOMContentLoaded", arguments.callee, false );
2936	jQuery.ready();
2937	}, false );
2938
2939	// If IE event model is used
2940	} else if ( document.attachEvent ) {
2941	// ensure firing before onload,
2942	// maybe late but safe also for iframes
2943	document.attachEvent("onreadystatechange", function(){
2944	if ( document.readyState === "complete" ) {
2945	document.detachEvent( "onreadystatechange", arguments.callee );
2946	jQuery.ready();
2947	}
2948	});
2949
2950	// If IE and not an iframe
2951	// continually check to see if the document is ready
2952	if ( document.documentElement.doScroll && typeof window.frameElement === "undefined" ) (function(){
2953	if ( jQuery.isReady ) return;
2954
2955	try {
2956	// If IE is used, use the trick by Diego Perini
2957	// http://javascript.nwbox.com/IEContentLoaded/
2958	document.documentElement.doScroll("left");
2959	} catch( error ) {
2960	setTimeout( arguments.callee, 0 );
2961	return;
2962	}
2963
2964	// and execute any waiting functions
2965	jQuery.ready();
2966	})();
2967	}
2968
2969	// A fallback to window.onload, that will always work
2970	jQuery.event.add( window, "load", jQuery.ready );
2971	}
2972
2973	jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
2974	"mousedown,mouseup,mousemove,mouseover,mouseout,mouseenter,mouseleave," +
2975	"change,select,submit,keydown,keypress,keyup,error").split(","), function(i, name){
2976
2977	// Handle event binding
2978	jQuery.fn[name] = function(fn){
2979	return fn ? this.bind(name, fn) : this.trigger(name);
2980	};
2981	});
2982
2983	// Prevent memory leaks in IE
2984	// And prevent errors on refresh with events like mouseover in other browsers
2985	// Window isn't included so as not to unbind existing unload events
2986	jQuery( window ).bind( 'unload', function(){
2987	for ( var id in jQuery.cache )
2988	// Skip the window
2989	if ( id != 1 && jQuery.cache[ id ].handle )
2990	jQuery.event.remove( jQuery.cache[ id ].handle.elem );
2991	});
2992	(function(){
2993
2994	jQuery.support = {};
2995
2996	var root = document.documentElement,
2997	script = document.createElement("script"),
2998	div = document.createElement("div"),
2999	id = "script" + (new Date).getTime();
3000
3001	div.style.display = "none";
3002	div.innerHTML = ' <link/><table></table><a href="/a" style="color:red;float:left;opacity:.5;">a</a><select><option>text</option></select><object><param/></object>';
3003
3004	var all = div.getElementsByTagName("*"),
3005	a = div.getElementsByTagName("a")[0];
3006
3007	// Can't get basic test support
3008	if ( !all \|\| !all.length \|\| !a ) {
3009	return;
3010	}
3011
3012	jQuery.support = {
3013	// IE strips leading whitespace when .innerHTML is used
3014	leadingWhitespace: div.firstChild.nodeType == 3,
3015
3016	// Make sure that tbody elements aren't automatically inserted
3017	// IE will insert them into empty tables
3018	tbody: !div.getElementsByTagName("tbody").length,
3019
3020	// Make sure that you can get all elements in an <object> element
3021	// IE 7 always returns no results
3022	objectAll: !!div.getElementsByTagName("object")[0]
3023	.getElementsByTagName("*").length,
3024
3025	// Make sure that link elements get serialized correctly by innerHTML
3026	// This requires a wrapper element in IE
3027	htmlSerialize: !!div.getElementsByTagName("link").length,
3028
3029	// Get the style information from getAttribute
3030	// (IE uses .cssText insted)
3031	style: /red/.test( a.getAttribute("style") ),
3032
3033	// Make sure that URLs aren't manipulated
3034	// (IE normalizes it by default)
3035	hrefNormalized: a.getAttribute("href") === "/a",
3036
3037	// Make sure that element opacity exists
3038	// (IE uses filter instead)
3039	opacity: a.style.opacity === "0.5",
3040
3041	// Verify style float existence
3042	// (IE uses styleFloat instead of cssFloat)
3043	cssFloat: !!a.style.cssFloat,
3044
3045	// Will be defined later
3046	scriptEval: false,
3047	noCloneEvent: true,
3048	boxModel: null
3049	};
3050
3051	script.type = "text/javascript";
3052	try {
3053	script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
3054	} catch(e){}
3055
3056	root.insertBefore( script, root.firstChild );
3057
3058	// Make sure that the execution of code works by injecting a script
3059	// tag with appendChild/createTextNode
3060	// (IE doesn't support this, fails, and uses .text instead)
3061	if ( window[ id ] ) {
3062	jQuery.support.scriptEval = true;
3063	delete window[ id ];
3064	}
3065
3066	root.removeChild( script );
3067
3068	if ( div.attachEvent && div.fireEvent ) {
3069	div.attachEvent("onclick", function(){
3070	// Cloning a node shouldn't copy over any
3071	// bound event handlers (IE does this)
3072	jQuery.support.noCloneEvent = false;
3073	div.detachEvent("onclick", arguments.callee);
3074	});
3075	div.cloneNode(true).fireEvent("onclick");
3076	}
3077
3078	// Figure out if the W3C box model works as expected
3079	// document.body must exist before we can do this
3080	jQuery(function(){
3081	var div = document.createElement("div");
3082	div.style.width = "1px";
3083	div.style.paddingLeft = "1px";
3084
3085	document.body.appendChild( div );
3086	jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
3087	document.body.removeChild( div );
3088	});
3089	})();
3090
3091	var styleFloat = jQuery.support.cssFloat ? "cssFloat" : "styleFloat";
3092
3093	jQuery.props = {
3094	"for": "htmlFor",
3095	"class": "className",
3096	"float": styleFloat,
3097	cssFloat: styleFloat,
3098	styleFloat: styleFloat,
3099	readonly: "readOnly",
3100	maxlength: "maxLength",
3101	cellspacing: "cellSpacing",
3102	rowspan: "rowSpan",
3103	tabindex: "tabIndex"
3104	};
3105	jQuery.fn.extend({
3106	// Keep a copy of the old load
3107	_load: jQuery.fn.load,
3108
3109	load: function( url, params, callback ) {
3110	if ( typeof url !== "string" )
3111	return this._load( url );
3112
3113	var off = url.indexOf(" ");
3114	if ( off >= 0 ) {
3115	var selector = url.slice(off, url.length);
3116	url = url.slice(0, off);
3117	}
3118
3119	// Default to a GET request
3120	var type = "GET";
3121
3122	// If the second parameter was provided
3123	if ( params )
3124	// If it's a function
3125	if ( jQuery.isFunction( params ) ) {
3126	// We assume that it's the callback
3127	callback = params;
3128	params = null;
3129
3130	// Otherwise, build a param string
3131	} else if( typeof params === "object" ) {
3132	params = jQuery.param( params );
3133	type = "POST";
3134	}
3135
3136	var self = this;
3137
3138	// Request the remote document
3139	jQuery.ajax({
3140	url: url,
3141	type: type,
3142	dataType: "html",
3143	data: params,
3144	complete: function(res, status){
3145	// If successful, inject the HTML into all the matched elements
3146	if ( status == "success" \|\| status == "notmodified" )
3147	// See if a selector was specified
3148	self.html( selector ?
3149	// Create a dummy div to hold the results
3150	jQuery("<div/>")
3151	// inject the contents of the document in, removing the scripts
3152	// to avoid any 'Permission Denied' errors in IE
3153	.append(res.responseText.replace(/<script(.\|\s)*?\/script>/g, ""))
3154
3155	// Locate the specified elements
3156	.find(selector) :
3157
3158	// If not, just inject the full result
3159	res.responseText );
3160
3161	if( callback )
3162	self.each( callback, [res.responseText, status, res] );
3163	}
3164	});
3165	return this;
3166	},
3167
3168	serialize: function() {
3169	return jQuery.param(this.serializeArray());
3170	},
3171	serializeArray: function() {
3172	return this.map(function(){
3173	return this.elements ? jQuery.makeArray(this.elements) : this;
3174	})
3175	.filter(function(){
3176	return this.name && !this.disabled &&
3177	(this.checked \|\| /select\|textarea/i.test(this.nodeName) \|\|
3178	/text\|hidden\|password/i.test(this.type));
3179	})
3180	.map(function(i, elem){
3181	var val = jQuery(this).val();
3182	return val == null ? null :
3183	jQuery.isArray(val) ?
3184	jQuery.map( val, function(val, i){
3185	return {name: elem.name, value: val};
3186	}) :
3187	{name: elem.name, value: val};
3188	}).get();
3189	}
3190	});
3191
3192	// Attach a bunch of functions for handling common AJAX events
3193	jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
3194	jQuery.fn[o] = function(f){
3195	return this.bind(o, f);
3196	};
3197	});
3198
3199	var jsc = now();
3200
3201	jQuery.extend({
3202
3203	get: function( url, data, callback, type ) {
3204	// shift arguments if data argument was ommited
3205	if ( jQuery.isFunction( data ) ) {
3206	callback = data;
3207	data = null;
3208	}
3209
3210	return jQuery.ajax({
3211	type: "GET",
3212	url: url,
3213	data: data,
3214	success: callback,
3215	dataType: type
3216	});
3217	},
3218
3219	getScript: function( url, callback ) {
3220	return jQuery.get(url, null, callback, "script");
3221	},
3222
3223	getJSON: function( url, data, callback ) {
3224	return jQuery.get(url, data, callback, "json");
3225	},
3226
3227	post: function( url, data, callback, type ) {
3228	if ( jQuery.isFunction( data ) ) {
3229	callback = data;
3230	data = {};
3231	}
3232
3233	return jQuery.ajax({
3234	type: "POST",
3235	url: url,
3236	data: data,
3237	success: callback,
3238	dataType: type
3239	});
3240	},
3241
3242	ajaxSetup: function( settings ) {
3243	jQuery.extend( jQuery.ajaxSettings, settings );
3244	},
3245
3246	ajaxSettings: {
3247	url: location.href,
3248	global: true,
3249	type: "GET",
3250	contentType: "application/x-www-form-urlencoded",
3251	processData: true,
3252	async: true,
3253	/*
3254	timeout: 0,
3255	data: null,
3256	username: null,
3257	password: null,
3258	*/
3259	// Create the request object; Microsoft failed to properly
3260	// implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
3261	// This function can be overriden by calling jQuery.ajaxSetup
3262	xhr:function(){
3263	return window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
3264	},
3265	accepts: {
3266	xml: "application/xml, text/xml",
3267	html: "text/html",
3268	script: "text/javascript, application/javascript",
3269	json: "application/json, text/javascript",
3270	text: "text/plain",
3271	_default: "/"
3272	}
3273	},
3274
3275	// Last-Modified header cache for next request
3276	lastModified: {},
3277
3278	ajax: function( s ) {
3279	// Extend the settings, but re-extend 's' so that it can be
3280	// checked again later (in the test suite, specifically)
3281	s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));
3282
3283	var jsonp, jsre = /=\?(&\|$)/g, status, data,
3284	type = s.type.toUpperCase();
3285
3286	// convert data if not already a string
3287	if ( s.data && s.processData && typeof s.data !== "string" )
3288	s.data = jQuery.param(s.data);
3289
3290	// Handle JSONP Parameter Callbacks
3291	if ( s.dataType == "jsonp" ) {
3292	if ( type == "GET" ) {
3293	if ( !s.url.match(jsre) )
3294	s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp \|\| "callback") + "=?";
3295	} else if ( !s.data \|\| !s.data.match(jsre) )
3296	s.data = (s.data ? s.data + "&" : "") + (s.jsonp \|\| "callback") + "=?";
3297	s.dataType = "json";
3298	}
3299
3300	// Build temporary JSONP function
3301	if ( s.dataType == "json" && (s.data && s.data.match(jsre) \|\| s.url.match(jsre)) ) {
3302	jsonp = "jsonp" + jsc++;
3303
3304	// Replace the =? sequence both in the query string and the data
3305	if ( s.data )
3306	s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
3307	s.url = s.url.replace(jsre, "=" + jsonp + "$1");
3308
3309	// We need to make sure
3310	// that a JSONP style response is executed properly
3311	s.dataType = "script";
3312
3313	// Handle JSONP-style loading
3314	window[ jsonp ] = function(tmp){
3315	data = tmp;
3316	success();
3317	complete();
3318	// Garbage collect
3319	window[ jsonp ] = undefined;
3320	try{ delete window[ jsonp ]; } catch(e){}
3321	if ( head )
3322	head.removeChild( script );
3323	};
3324	}
3325
3326	if ( s.dataType == "script" && s.cache == null )
3327	s.cache = false;
3328
3329	if ( s.cache === false && type == "GET" ) {
3330	var ts = now();
3331	// try replacing _= if it is there
3332	var ret = s.url.replace(/(\?\|&)_=.*?(&\|$)/, "$1_=" + ts + "$2");
3333	// if nothing was replaced, add timestamp to the end
3334	s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");
3335	}
3336
3337	// If data is available, append data to url for get requests
3338	if ( s.data && type == "GET" ) {
3339	s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;
3340
3341	// IE likes to send both get and post data, prevent this
3342	s.data = null;
3343	}
3344
3345	// Watch for a new set of requests
3346	if ( s.global && ! jQuery.active++ )
3347	jQuery.event.trigger( "ajaxStart" );
3348
3349	// Matches an absolute URL, and saves the domain
3350	var parts = /^(\w+:)?\/\/([^\/?#]+)/.exec( s.url );
3351
3352	// If we're requesting a remote document
3353	// and trying to load JSON or Script with a GET
3354	if ( s.dataType == "script" && type == "GET" && parts
3355	&& ( parts[1] && parts[1] != location.protocol \|\| parts[2] != location.host )){
3356
3357	var head = document.getElementsByTagName("head")[0];
3358	var script = document.createElement("script");
3359	script.src = s.url;
3360	if (s.scriptCharset)
3361	script.charset = s.scriptCharset;
3362
3363	// Handle Script loading
3364	if ( !jsonp ) {
3365	var done = false;
3366
3367	// Attach handlers for all browsers
3368	script.onload = script.onreadystatechange = function(){
3369	if ( !done && (!this.readyState \|\|
3370	this.readyState == "loaded" \|\| this.readyState == "complete") ) {
3371	done = true;
3372	success();
3373	complete();
3374	head.removeChild( script );
3375	}
3376	};
3377	}
3378
3379	head.appendChild(script);
3380
3381	// We handle everything using the script element injection
3382	return undefined;
3383	}
3384
3385	var requestDone = false;
3386
3387	// Create the request object
3388	var xhr = s.xhr();
3389
3390	// Open the socket
3391	// Passing null username, generates a login popup on Opera (#2865)
3392	if( s.username )
3393	xhr.open(type, s.url, s.async, s.username, s.password);
3394	else
3395	xhr.open(type, s.url, s.async);
3396
3397	// Need an extra try/catch for cross domain requests in Firefox 3
3398	try {
3399	// Set the correct header, if data is being sent
3400	if ( s.data )
3401	xhr.setRequestHeader("Content-Type", s.contentType);
3402
3403	// Set the If-Modified-Since header, if ifModified mode.
3404	if ( s.ifModified )
3405	xhr.setRequestHeader("If-Modified-Since",
3406	jQuery.lastModified[s.url] \|\| "Thu, 01 Jan 1970 00:00:00 GMT" );
3407
3408	// Set header so the called script knows that it's an XMLHttpRequest
3409	xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
3410
3411	// Set the Accepts header for the server, depending on the dataType
3412	xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
3413	s.accepts[ s.dataType ] + ", /" :
3414	s.accepts._default );
3415	} catch(e){}
3416
3417	// Allow custom headers/mimetypes and early abort
3418	if ( s.beforeSend && s.beforeSend(xhr, s) === false ) {
3419	// Handle the global AJAX counter
3420	if ( s.global && ! --jQuery.active )
3421	jQuery.event.trigger( "ajaxStop" );
3422	// close opended socket
3423	xhr.abort();
3424	return false;
3425	}
3426
3427	if ( s.global )
3428	jQuery.event.trigger("ajaxSend", [xhr, s]);
3429
3430	// Wait for a response to come back
3431	var onreadystatechange = function(isTimeout){
3432	// The request was aborted, clear the interval and decrement jQuery.active
3433	if (xhr.readyState == 0) {
3434	if (ival) {
3435	// clear poll interval
3436	clearInterval(ival);
3437	ival = null;
3438	// Handle the global AJAX counter
3439	if ( s.global && ! --jQuery.active )
3440	jQuery.event.trigger( "ajaxStop" );
3441	}
3442	// The transfer is complete and the data is available, or the request timed out
3443	} else if ( !requestDone && xhr && (xhr.readyState == 4 \|\| isTimeout == "timeout") ) {
3444	requestDone = true;
3445
3446	// clear poll interval
3447	if (ival) {
3448	clearInterval(ival);
3449	ival = null;
3450	}
3451
3452	status = isTimeout == "timeout" ? "timeout" :
3453	!jQuery.httpSuccess( xhr ) ? "error" :
3454	s.ifModified && jQuery.httpNotModified( xhr, s.url ) ? "notmodified" :
3455	"success";
3456
3457	if ( status == "success" ) {
3458	// Watch for, and catch, XML document parse errors
3459	try {
3460	// process the data (runs the xml through httpData regardless of callback)
3461	data = jQuery.httpData( xhr, s.dataType, s );
3462	} catch(e) {
3463	status = "parsererror";
3464	}
3465	}
3466
3467	// Make sure that the request was successful or notmodified
3468	if ( status == "success" ) {
3469	// Cache Last-Modified header, if ifModified mode.
3470	var modRes;
3471	try {
3472	modRes = xhr.getResponseHeader("Last-Modified");
3473	} catch(e) {} // swallow exception thrown by FF if header is not available
3474
3475	if ( s.ifModified && modRes )
3476	jQuery.lastModified[s.url] = modRes;
3477
3478	// JSONP handles its own success callback
3479	if ( !jsonp )
3480	success();
3481	} else
3482	jQuery.handleError(s, xhr, status);
3483
3484	// Fire the complete handlers
3485	complete();
3486
3487	if ( isTimeout )
3488	xhr.abort();
3489
3490	// Stop memory leaks
3491	if ( s.async )
3492	xhr = null;
3493	}
3494	};
3495
3496	if ( s.async ) {
3497	// don't attach the handler to the request, just poll it instead
3498	var ival = setInterval(onreadystatechange, 13);
3499
3500	// Timeout checker
3501	if ( s.timeout > 0 )
3502	setTimeout(function(){
3503	// Check to see if the request is still happening
3504	if ( xhr && !requestDone )
3505	onreadystatechange( "timeout" );
3506	}, s.timeout);
3507	}
3508
3509	// Send the data
3510	try {
3511	xhr.send(s.data);
3512	} catch(e) {
3513	jQuery.handleError(s, xhr, null, e);
3514	}
3515
3516	// firefox 1.5 doesn't fire statechange for sync requests
3517	if ( !s.async )
3518	onreadystatechange();
3519
3520	function success(){
3521	// If a local callback was specified, fire it and pass it the data
3522	if ( s.success )
3523	s.success( data, status );
3524
3525	// Fire the global callback
3526	if ( s.global )
3527	jQuery.event.trigger( "ajaxSuccess", [xhr, s] );
3528	}
3529
3530	function complete(){
3531	// Process result
3532	if ( s.complete )
3533	s.complete(xhr, status);
3534
3535	// The request was completed
3536	if ( s.global )
3537	jQuery.event.trigger( "ajaxComplete", [xhr, s] );
3538
3539	// Handle the global AJAX counter
3540	if ( s.global && ! --jQuery.active )
3541	jQuery.event.trigger( "ajaxStop" );
3542	}
3543
3544	// return XMLHttpRequest to allow aborting the request etc.
3545	return xhr;
3546	},
3547
3548	handleError: function( s, xhr, status, e ) {
3549	// If a local callback was specified, fire it
3550	if ( s.error ) s.error( xhr, status, e );
3551
3552	// Fire the global callback
3553	if ( s.global )
3554	jQuery.event.trigger( "ajaxError", [xhr, s, e] );
3555	},
3556
3557	// Counter for holding the number of active queries
3558	active: 0,
3559
3560	// Determines if an XMLHttpRequest was successful or not
3561	httpSuccess: function( xhr ) {
3562	try {
3563	// IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
3564	return !xhr.status && location.protocol == "file:" \|\|
3565	( xhr.status >= 200 && xhr.status < 300 ) \|\| xhr.status == 304 \|\| xhr.status == 1223;
3566	} catch(e){}
3567	return false;
3568	},
3569
3570	// Determines if an XMLHttpRequest returns NotModified
3571	httpNotModified: function( xhr, url ) {
3572	try {
3573	var xhrRes = xhr.getResponseHeader("Last-Modified");
3574
3575	// Firefox always returns 200. check Last-Modified date
3576	return xhr.status == 304 \|\| xhrRes == jQuery.lastModified[url];
3577	} catch(e){}
3578	return false;
3579	},
3580
3581	httpData: function( xhr, type, s ) {
3582	var ct = xhr.getResponseHeader("content-type"),
3583	xml = type == "xml" \|\| !type && ct && ct.indexOf("xml") >= 0,
3584	data = xml ? xhr.responseXML : xhr.responseText;
3585
3586	if ( xml && data.documentElement.tagName == "parsererror" )
3587	throw "parsererror";
3588
3589	// Allow a pre-filtering function to sanitize the response
3590	// s != null is checked to keep backwards compatibility
3591	if( s && s.dataFilter )
3592	data = s.dataFilter( data, type );
3593
3594	// The filter can actually parse the response
3595	if( typeof data === "string" ){
3596
3597	// If the type is "script", eval it in global context
3598	if ( type == "script" )
3599	jQuery.globalEval( data );
3600
3601	// Get the JavaScript object, if JSON is used.
3602	if ( type == "json" )
3603	data = window["eval"]("(" + data + ")");
3604	}
3605
3606	return data;
3607	},
3608
3609	// Serialize an array of form elements or a set of
3610	// key/values into a query string
3611	param: function( a ) {
3612	var s = [ ];
3613
3614	function add( key, value ){
3615	s[ s.length ] = encodeURIComponent(key) + '=' + encodeURIComponent(value);
3616	};
3617
3618	// If an array was passed in, assume that it is an array
3619	// of form elements
3620	if ( jQuery.isArray(a) \|\| a.jquery )
3621	// Serialize the form elements
3622	jQuery.each( a, function(){
3623	add( this.name, this.value );
3624	});
3625
3626	// Otherwise, assume that it's an object of key/value pairs
3627	else
3628	// Serialize the key/values
3629	for ( var j in a )
3630	// If the value is an array then the key names need to be repeated
3631	if ( jQuery.isArray(a[j]) )
3632	jQuery.each( a[j], function(){
3633	add( j, this );
3634	});
3635	else
3636	add( j, jQuery.isFunction(a[j]) ? a[j]() : a[j] );
3637
3638	// Return the resulting serialization
3639	return s.join("&").replace(/%20/g, "+");
3640	}
3641
3642	});
3643	var elemdisplay = {},
3644	timerId,
3645	fxAttrs = [
3646	// height animations
3647	[ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
3648	// width animations
3649	[ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
3650	// opacity animations
3651	[ "opacity" ]
3652	];
3653
3654	function genFx( type, num ){
3655	var obj = {};
3656	jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function(){
3657	obj[ this ] = type;
3658	});
3659	return obj;
3660	}
3661
3662	jQuery.fn.extend({
3663	show: function(speed,callback){
3664	if ( speed ) {
3665	return this.animate( genFx("show", 3), speed, callback);
3666	} else {
3667	for ( var i = 0, l = this.length; i < l; i++ ){
3668	var old = jQuery.data(this[i], "olddisplay");
3669
3670	this[i].style.display = old \|\| "";
3671
3672	if ( jQuery.css(this[i], "display") === "none" ) {
3673	var tagName = this[i].tagName, display;
3674
3675	if ( elemdisplay[ tagName ] ) {
3676	display = elemdisplay[ tagName ];
3677	} else {
3678	var elem = jQuery("<" + tagName + " />").appendTo("body");
3679
3680	display = elem.css("display");
3681	if ( display === "none" )
3682	display = "block";
3683
3684	elem.remove();
3685
3686	elemdisplay[ tagName ] = display;
3687	}
3688
3689	this[i].style.display = jQuery.data(this[i], "olddisplay", display);
3690	}
3691	}
3692
3693	return this;
3694	}
3695	},
3696
3697	hide: function(speed,callback){
3698	if ( speed ) {
3699	return this.animate( genFx("hide", 3), speed, callback);
3700	} else {
3701	for ( var i = 0, l = this.length; i < l; i++ ){
3702	var old = jQuery.data(this[i], "olddisplay");
3703	if ( !old && old !== "none" )
3704	jQuery.data(this[i], "olddisplay", jQuery.css(this[i], "display"));
3705	this[i].style.display = "none";
3706	}
3707	return this;
3708	}
3709	},
3710
3711	// Save the old toggle function
3712	_toggle: jQuery.fn.toggle,
3713
3714	toggle: function( fn, fn2 ){
3715	var bool = typeof fn === "boolean";
3716
3717	return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
3718	this._toggle.apply( this, arguments ) :
3719	fn == null \|\| bool ?
3720	this.each(function(){
3721	var state = bool ? fn : jQuery(this).is(":hidden");
3722	jQuery(this)[ state ? "show" : "hide" ]();
3723	}) :
3724	this.animate(genFx("toggle", 3), fn, fn2);
3725	},
3726
3727	fadeTo: function(speed,to,callback){
3728	return this.animate({opacity: to}, speed, callback);
3729	},
3730
3731	animate: function( prop, speed, easing, callback ) {
3732	var optall = jQuery.speed(speed, easing, callback);
3733
3734	return this[ optall.queue === false ? "each" : "queue" ](function(){
3735
3736	var opt = jQuery.extend({}, optall), p,
3737	hidden = this.nodeType == 1 && jQuery(this).is(":hidden"),
3738	self = this;
3739
3740	for ( p in prop ) {
3741	if ( prop[p] == "hide" && hidden \|\| prop[p] == "show" && !hidden )
3742	return opt.complete.call(this);
3743
3744	if ( ( p == "height" \|\| p == "width" ) && this.style ) {
3745	// Store display property
3746	opt.display = jQuery.css(this, "display");
3747
3748	// Make sure that nothing sneaks out
3749	opt.overflow = this.style.overflow;
3750	}
3751	}
3752
3753	if ( opt.overflow != null )
3754	this.style.overflow = "hidden";
3755
3756	opt.curAnim = jQuery.extend({}, prop);
3757
3758	jQuery.each( prop, function(name, val){
3759	var e = new jQuery.fx( self, opt, name );
3760
3761	if ( /toggle\|show\|hide/.test(val) )
3762	e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
3763	else {
3764	var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
3765	start = e.cur(true) \|\| 0;
3766
3767	if ( parts ) {
3768	var end = parseFloat(parts[2]),
3769	unit = parts[3] \|\| "px";
3770
3771	// We need to compute starting value
3772	if ( unit != "px" ) {
3773	self.style[ name ] = (end \|\| 1) + unit;
3774	start = ((end \|\| 1) / e.cur(true)) * start;
3775	self.style[ name ] = start + unit;
3776	}
3777
3778	// If a +=/-= token was provided, we're doing a relative animation
3779	if ( parts[1] )
3780	end = ((parts[1] == "-=" ? -1 : 1) * end) + start;
3781
3782	e.custom( start, end, unit );
3783	} else
3784	e.custom( start, val, "" );
3785	}
3786	});
3787
3788	// For JS strict compliance
3789	return true;
3790	});
3791	},
3792
3793	stop: function(clearQueue, gotoEnd){
3794	var timers = jQuery.timers;
3795
3796	if (clearQueue)
3797	this.queue([]);
3798
3799	this.each(function(){
3800	// go in reverse order so anything added to the queue during the loop is ignored
3801	for ( var i = timers.length - 1; i >= 0; i-- )
3802	if ( timers[i].elem == this ) {
3803	if (gotoEnd)
3804	// force the next step to be the last
3805	timers[i](true);
3806	timers.splice(i, 1);
3807	}
3808	});
3809
3810	// start the next in the queue if the last step wasn't forced
3811	if (!gotoEnd)
3812	this.dequeue();
3813
3814	return this;
3815	}
3816
3817	});
3818
3819	// Generate shortcuts for custom animations
3820	jQuery.each({
3821	slideDown: genFx("show", 1),
3822	slideUp: genFx("hide", 1),
3823	slideToggle: genFx("toggle", 1),
3824	fadeIn: { opacity: "show" },
3825	fadeOut: { opacity: "hide" }
3826	}, function( name, props ){
3827	jQuery.fn[ name ] = function( speed, callback ){
3828	return this.animate( props, speed, callback );
3829	};
3830	});
3831
3832	jQuery.extend({
3833
3834	speed: function(speed, easing, fn) {
3835	var opt = typeof speed === "object" ? speed : {
3836	complete: fn \|\| !fn && easing \|\|
3837	jQuery.isFunction( speed ) && speed,
3838	duration: speed,
3839	easing: fn && easing \|\| easing && !jQuery.isFunction(easing) && easing
3840	};
3841
3842	opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
3843	jQuery.fx.speeds[opt.duration] \|\| jQuery.fx.speeds._default;
3844
3845	// Queueing
3846	opt.old = opt.complete;
3847	opt.complete = function(){
3848	if ( opt.queue !== false )
3849	jQuery(this).dequeue();
3850	if ( jQuery.isFunction( opt.old ) )
3851	opt.old.call( this );
3852	};
3853
3854	return opt;
3855	},
3856
3857	easing: {
3858	linear: function( p, n, firstNum, diff ) {
3859	return firstNum + diff * p;
3860	},
3861	swing: function( p, n, firstNum, diff ) {
3862	return ((-Math.cos(pMath.PI)/2) + 0.5) diff + firstNum;
3863	}
3864	},
3865
3866	timers: [],
3867
3868	fx: function( elem, options, prop ){
3869	this.options = options;
3870	this.elem = elem;
3871	this.prop = prop;
3872
3873	if ( !options.orig )
3874	options.orig = {};
3875	}
3876
3877	});
3878
3879	jQuery.fx.prototype = {
3880
3881	// Simple function for setting a style value
3882	update: function(){
3883	if ( this.options.step )
3884	this.options.step.call( this.elem, this.now, this );
3885
3886	(jQuery.fx.step[this.prop] \|\| jQuery.fx.step._default)( this );
3887
3888	// Set display property to block for height/width animations
3889	if ( ( this.prop == "height" \|\| this.prop == "width" ) && this.elem.style )
3890	this.elem.style.display = "block";
3891	},
3892
3893	// Get the current size
3894	cur: function(force){
3895	if ( this.elem[this.prop] != null && (!this.elem.style \|\| this.elem.style[this.prop] == null) )
3896	return this.elem[ this.prop ];
3897
3898	var r = parseFloat(jQuery.css(this.elem, this.prop, force));
3899	return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) \|\| 0;
3900	},
3901
3902	// Start an animation from one number to another
3903	custom: function(from, to, unit){
3904	this.startTime = now();
3905	this.start = from;
3906	this.end = to;
3907	this.unit = unit \|\| this.unit \|\| "px";
3908	this.now = this.start;
3909	this.pos = this.state = 0;
3910
3911	var self = this;
3912	function t(gotoEnd){
3913	return self.step(gotoEnd);
3914	}
3915
3916	t.elem = this.elem;
3917
3918	if ( t() && jQuery.timers.push(t) == 1 ) {
3919	timerId = setInterval(function(){
3920	var timers = jQuery.timers;
3921
3922	for ( var i = 0; i < timers.length; i++ )
3923	if ( !timers[i]() )
3924	timers.splice(i--, 1);
3925
3926	if ( !timers.length ) {
3927	clearInterval( timerId );
3928	}
3929	}, 13);
3930	}
3931	},
3932
3933	// Simple 'show' function
3934	show: function(){
3935	// Remember where we started, so that we can go back to it later
3936	this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
3937	this.options.show = true;
3938
3939	// Begin the animation
3940	// Make sure that we start at a small width/height to avoid any
3941	// flash of content
3942	this.custom(this.prop == "width" \|\| this.prop == "height" ? 1 : 0, this.cur());
3943
3944	// Start by showing the element
3945	jQuery(this.elem).show();
3946	},
3947
3948	// Simple 'hide' function
3949	hide: function(){
3950	// Remember where we started, so that we can go back to it later
3951	this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
3952	this.options.hide = true;
3953
3954	// Begin the animation
3955	this.custom(this.cur(), 0);
3956	},
3957
3958	// Each step of an animation
3959	step: function(gotoEnd){
3960	var t = now();
3961
3962	if ( gotoEnd \|\| t >= this.options.duration + this.startTime ) {
3963	this.now = this.end;
3964	this.pos = this.state = 1;
3965	this.update();
3966
3967	this.options.curAnim[ this.prop ] = true;
3968
3969	var done = true;
3970	for ( var i in this.options.curAnim )
3971	if ( this.options.curAnim[i] !== true )
3972	done = false;
3973
3974	if ( done ) {
3975	if ( this.options.display != null ) {
3976	// Reset the overflow
3977	this.elem.style.overflow = this.options.overflow;
3978
3979	// Reset the display
3980	this.elem.style.display = this.options.display;
3981	if ( jQuery.css(this.elem, "display") == "none" )
3982	this.elem.style.display = "block";
3983	}
3984
3985	// Hide the element if the "hide" operation was done
3986	if ( this.options.hide )
3987	jQuery(this.elem).hide();
3988
3989	// Reset the properties, if the item has been hidden or shown
3990	if ( this.options.hide \|\| this.options.show )
3991	for ( var p in this.options.curAnim )
3992	jQuery.attr(this.elem.style, p, this.options.orig[p]);
3993
3994	// Execute the complete function
3995	this.options.complete.call( this.elem );
3996	}
3997
3998	return false;
3999	} else {
4000	var n = t - this.startTime;
4001	this.state = n / this.options.duration;
4002
4003	// Perform the easing function, defaults to swing
4004	this.pos = jQuery.easing[this.options.easing \|\| (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
4005	this.now = this.start + ((this.end - this.start) * this.pos);
4006
4007	// Perform the next step of the animation
4008	this.update();
4009	}
4010
4011	return true;
4012	}
4013
4014	};
4015
4016	jQuery.extend( jQuery.fx, {
4017	speeds:{
4018	slow: 600,
4019	fast: 200,
4020	// Default speed
4021	_default: 400
4022	},
4023	step: {
4024
4025	opacity: function(fx){
4026	jQuery.attr(fx.elem.style, "opacity", fx.now);
4027	},
4028
4029	_default: function(fx){
4030	if ( fx.elem.style && fx.elem.style[ fx.prop ] != null )
4031	fx.elem.style[ fx.prop ] = fx.now + fx.unit;
4032	else
4033	fx.elem[ fx.prop ] = fx.now;
4034	}
4035	}
4036	});
4037	if ( document.documentElement["getBoundingClientRect"] )
4038	jQuery.fn.offset = function() {
4039	if ( !this[0] ) return { top: 0, left: 0 };
4040	if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] );
4041	var box = this[0].getBoundingClientRect(), doc = this[0].ownerDocument, body = doc.body, docElem = doc.documentElement,
4042	clientTop = docElem.clientTop \|\| body.clientTop \|\| 0, clientLeft = docElem.clientLeft \|\| body.clientLeft \|\| 0,
4043	top = box.top + (self.pageYOffset \|\| jQuery.boxModel && docElem.scrollTop \|\| body.scrollTop ) - clientTop,
4044	left = box.left + (self.pageXOffset \|\| jQuery.boxModel && docElem.scrollLeft \|\| body.scrollLeft) - clientLeft;
4045	return { top: top, left: left };
4046	};
4047	else
4048	jQuery.fn.offset = function() {
4049	if ( !this[0] ) return { top: 0, left: 0 };
4050	if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] );
4051	jQuery.offset.initialized \|\| jQuery.offset.initialize();
4052
4053	var elem = this[0], offsetParent = elem.offsetParent, prevOffsetParent = elem,
4054	doc = elem.ownerDocument, computedStyle, docElem = doc.documentElement,
4055	body = doc.body, defaultView = doc.defaultView,
4056	prevComputedStyle = defaultView.getComputedStyle(elem, null),
4057	top = elem.offsetTop, left = elem.offsetLeft;
4058
4059	while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
4060	computedStyle = defaultView.getComputedStyle(elem, null);
4061	top -= elem.scrollTop, left -= elem.scrollLeft;
4062	if ( elem === offsetParent ) {
4063	top += elem.offsetTop, left += elem.offsetLeft;
4064	if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && /^t(able\|d\|h)$/i.test(elem.tagName)) )
4065	top += parseInt( computedStyle.borderTopWidth, 10) \|\| 0,
4066	left += parseInt( computedStyle.borderLeftWidth, 10) \|\| 0;
4067	prevOffsetParent = offsetParent, offsetParent = elem.offsetParent;
4068	}
4069	if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" )
4070	top += parseInt( computedStyle.borderTopWidth, 10) \|\| 0,
4071	left += parseInt( computedStyle.borderLeftWidth, 10) \|\| 0;
4072	prevComputedStyle = computedStyle;
4073	}
4074
4075	if ( prevComputedStyle.position === "relative" \|\| prevComputedStyle.position === "static" )
4076	top += body.offsetTop,
4077	left += body.offsetLeft;
4078
4079	if ( prevComputedStyle.position === "fixed" )
4080	top += Math.max(docElem.scrollTop, body.scrollTop),
4081	left += Math.max(docElem.scrollLeft, body.scrollLeft);
4082
4083	return { top: top, left: left };
4084	};
4085
4086	jQuery.offset = {
4087	initialize: function() {
4088	if ( this.initialized ) return;
4089	var body = document.body, container = document.createElement('div'), innerDiv, checkDiv, table, td, rules, prop, bodyMarginTop = body.style.marginTop,
4090	html = '<div style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;"><div></div></div><table style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;" cellpadding="0" cellspacing="0"><tr><td></td></tr></table>';
4091
4092	rules = { position: 'absolute', top: 0, left: 0, margin: 0, border: 0, width: '1px', height: '1px', visibility: 'hidden' };
4093	for ( prop in rules ) container.style[prop] = rules[prop];
4094
4095	container.innerHTML = html;
4096	body.insertBefore(container, body.firstChild);
4097	innerDiv = container.firstChild, checkDiv = innerDiv.firstChild, td = innerDiv.nextSibling.firstChild.firstChild;
4098
4099	this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
4100	this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
4101
4102	innerDiv.style.overflow = 'hidden', innerDiv.style.position = 'relative';
4103	this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
4104
4105	body.style.marginTop = '1px';
4106	this.doesNotIncludeMarginInBodyOffset = (body.offsetTop === 0);
4107	body.style.marginTop = bodyMarginTop;
4108
4109	body.removeChild(container);
4110	this.initialized = true;
4111	},
4112
4113	bodyOffset: function(body) {
4114	jQuery.offset.initialized \|\| jQuery.offset.initialize();
4115	var top = body.offsetTop, left = body.offsetLeft;
4116	if ( jQuery.offset.doesNotIncludeMarginInBodyOffset )
4117	top += parseInt( jQuery.curCSS(body, 'marginTop', true), 10 ) \|\| 0,
4118	left += parseInt( jQuery.curCSS(body, 'marginLeft', true), 10 ) \|\| 0;
4119	return { top: top, left: left };
4120	}
4121	};
4122
4123
4124	jQuery.fn.extend({
4125	position: function() {
4126	var left = 0, top = 0, results;
4127
4128	if ( this[0] ) {
4129	// Get real offsetParent
4130	var offsetParent = this.offsetParent(),
4131
4132	// Get correct offsets
4133	offset = this.offset(),
4134	parentOffset = /^body\|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset();
4135
4136	// Subtract element margins
4137	// note: when an element has margin: auto the offsetLeft and marginLeft
4138	// are the same in Safari causing offset.left to incorrectly be 0
4139	offset.top -= num( this, 'marginTop' );
4140	offset.left -= num( this, 'marginLeft' );
4141
4142	// Add offsetParent borders
4143	parentOffset.top += num( offsetParent, 'borderTopWidth' );
4144	parentOffset.left += num( offsetParent, 'borderLeftWidth' );
4145
4146	// Subtract the two offsets
4147	results = {
4148	top: offset.top - parentOffset.top,
4149	left: offset.left - parentOffset.left
4150	};
4151	}
4152
4153	return results;
4154	},
4155
4156	offsetParent: function() {
4157	var offsetParent = this[0].offsetParent \|\| document.body;
4158	while ( offsetParent && (!/^body\|html$/i.test(offsetParent.tagName) && jQuery.css(offsetParent, 'position') == 'static') )
4159	offsetParent = offsetParent.offsetParent;
4160	return jQuery(offsetParent);
4161	}
4162	});
4163
4164
4165	// Create scrollLeft and scrollTop methods
4166	jQuery.each( ['Left', 'Top'], function(i, name) {
4167	var method = 'scroll' + name;
4168
4169	jQuery.fn[ method ] = function(val) {
4170	if (!this[0]) return null;
4171
4172	return val !== undefined ?
4173
4174	// Set the scroll offset
4175	this.each(function() {
4176	this == window \|\| this == document ?
4177	window.scrollTo(
4178	!i ? val : jQuery(window).scrollLeft(),
4179	i ? val : jQuery(window).scrollTop()
4180	) :
4181	this[ method ] = val;
4182	}) :
4183
4184	// Return the scroll offset
4185	this[0] == window \|\| this[0] == document ?
4186	self[ i ? 'pageYOffset' : 'pageXOffset' ] \|\|
4187	jQuery.boxModel && document.documentElement[ method ] \|\|
4188	document.body[ method ] :
4189	this[0][ method ];
4190	};
4191	});
4192	// Create innerHeight, innerWidth, outerHeight and outerWidth methods
4193	jQuery.each([ "Height", "Width" ], function(i, name){
4194
4195	var tl = i ? "Left" : "Top", // top or left
4196	br = i ? "Right" : "Bottom"; // bottom or right
4197
4198	// innerHeight and innerWidth
4199	jQuery.fn["inner" + name] = function(){
4200	return this[ name.toLowerCase() ]() +
4201	num(this, "padding" + tl) +
4202	num(this, "padding" + br);
4203	};
4204
4205	// outerHeight and outerWidth
4206	jQuery.fn["outer" + name] = function(margin) {
4207	return this["inner" + name]() +
4208	num(this, "border" + tl + "Width") +
4209	num(this, "border" + br + "Width") +
4210	(margin ?
4211	num(this, "margin" + tl) + num(this, "margin" + br) : 0);
4212	};
4213
4214	var type = name.toLowerCase();
4215
4216	jQuery.fn[ type ] = function( size ) {
4217	// Get window width or height
4218	return this[0] == window ?
4219	// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
4220	document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] \|\|
4221	document.body[ "client" + name ] :
4222
4223	// Get document width or height
4224	this[0] == document ?
4225	// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
4226	Math.max(
4227	document.documentElement["client" + name],
4228	document.body["scroll" + name], document.documentElement["scroll" + name],
4229	document.body["offset" + name], document.documentElement["offset" + name]
4230	) :
4231
4232	// Get or set width or height on the element
4233	size === undefined ?
4234	// Get width or height on the element
4235	(this.length ? jQuery.css( this[0], type ) : null) :
4236
4237	// Set the width or height on the element (default to pixels if value is unitless)
4238	this.css( type, typeof size === "string" ? size : size + "px" );
4239	};
4240
4241	});})();

Notatka: Zobacz TracBrowser aby uzyskać więcej informacji.

Pobierz w innym formacie: