Subversion Repositories Sites.obs-saisons.fr

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
40 aurelien 1
/*!
2
 * jQuery JavaScript Library v1.4.2
3
 * http://jquery.com/
4
 *
5
 * Copyright 2010, John Resig
6
 * Dual licensed under the MIT or GPL Version 2 licenses.
7
 * http://jquery.org/license
8
 *
9
 * Includes Sizzle.js
10
 * http://sizzlejs.com/
11
 * Copyright 2010, The Dojo Foundation
12
 * Released under the MIT, BSD, and GPL Licenses.
13
 *
14
 * Date: Sat Feb 13 22:33:48 2010 -0500
15
 */
16
(function( window, undefined ) {
17
 
18
// Define a local copy of jQuery
19
var jQuery = function( selector, context ) {
20
		// The jQuery object is actually just the init constructor 'enhanced'
21
		return new jQuery.fn.init( selector, context );
22
	},
23
 
24
	// Map over jQuery in case of overwrite
25
	_jQuery = window.jQuery,
26
 
27
	// Map over the $ in case of overwrite
28
	_$ = window.$,
29
 
30
	// Use the correct document accordingly with window argument (sandbox)
31
	document = window.document,
32
 
33
	// A central reference to the root jQuery(document)
34
	rootjQuery,
35
 
36
	// A simple way to check for HTML strings or ID strings
37
	// (both of which we optimize for)
38
	quickExpr = /^[^<]*(<[\w\W]+>)[^>]*$|^#([\w-]+)$/,
39
 
40
	// Is it a simple selector
41
	isSimple = /^.[^:#\[\.,]*$/,
42
 
43
	// Check if a string has a non-whitespace character in it
44
	rnotwhite = /\S/,
45
 
46
	// Used for trimming whitespace
47
	rtrim = /^(\s|\u00A0)+|(\s|\u00A0)+$/g,
48
 
49
	// Match a standalone tag
50
	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
51
 
52
	// Keep a UserAgent string for use with jQuery.browser
53
	userAgent = navigator.userAgent,
54
 
55
	// For matching the engine and version of the browser
56
	browserMatch,
57
 
58
	// Has the ready events already been bound?
59
	readyBound = false,
60
 
61
	// The functions to execute on DOM ready
62
	readyList = [],
63
 
64
	// The ready event handler
65
	DOMContentLoaded,
66
 
67
	// Save a reference to some core methods
68
	toString = Object.prototype.toString,
69
	hasOwnProperty = Object.prototype.hasOwnProperty,
70
	push = Array.prototype.push,
71
	slice = Array.prototype.slice,
72
	indexOf = Array.prototype.indexOf;
73
 
74
jQuery.fn = jQuery.prototype = {
75
	init: function( selector, context ) {
76
		var match, elem, ret, doc;
77
 
78
		// Handle $(""), $(null), or $(undefined)
79
		if ( !selector ) {
80
			return this;
81
		}
82
 
83
		// Handle $(DOMElement)
84
		if ( selector.nodeType ) {
85
			this.context = this[0] = selector;
86
			this.length = 1;
87
			return this;
88
		}
89
 
90
		// The body element only exists once, optimize finding it
91
		if ( selector === "body" && !context ) {
92
			this.context = document;
93
			this[0] = document.body;
94
			this.selector = "body";
95
			this.length = 1;
96
			return this;
97
		}
98
 
99
		// Handle HTML strings
100
		if ( typeof selector === "string" ) {
101
			// Are we dealing with HTML string or an ID?
102
			match = quickExpr.exec( selector );
103
 
104
			// Verify a match, and that no context was specified for #id
105
			if ( match && (match[1] || !context) ) {
106
 
107
				// HANDLE: $(html) -> $(array)
108
				if ( match[1] ) {
109
					doc = (context ? context.ownerDocument || context : document);
110
 
111
					// If a single string is passed in and it's a single tag
112
					// just do a createElement and skip the rest
113
					ret = rsingleTag.exec( selector );
114
 
115
					if ( ret ) {
116
						if ( jQuery.isPlainObject( context ) ) {
117
							selector = [ document.createElement( ret[1] ) ];
118
							jQuery.fn.attr.call( selector, context, true );
119
 
120
						} else {
121
							selector = [ doc.createElement( ret[1] ) ];
122
						}
123
 
124
					} else {
125
						ret = buildFragment( [ match[1] ], [ doc ] );
126
						selector = (ret.cacheable ? ret.fragment.cloneNode(true) : ret.fragment).childNodes;
127
					}
128
 
129
					return jQuery.merge( this, selector );
130
 
131
				// HANDLE: $("#id")
132
				} else {
133
					elem = document.getElementById( match[2] );
134
 
135
					if ( elem ) {
136
						// Handle the case where IE and Opera return items
137
						// by name instead of ID
138
						if ( elem.id !== match[2] ) {
139
							return rootjQuery.find( selector );
140
						}
141
 
142
						// Otherwise, we inject the element directly into the jQuery object
143
						this.length = 1;
144
						this[0] = elem;
145
					}
146
 
147
					this.context = document;
148
					this.selector = selector;
149
					return this;
150
				}
151
 
152
			// HANDLE: $("TAG")
153
			} else if ( !context && /^\w+$/.test( selector ) ) {
154
				this.selector = selector;
155
				this.context = document;
156
				selector = document.getElementsByTagName( selector );
157
				return jQuery.merge( this, selector );
158
 
159
			// HANDLE: $(expr, $(...))
160
			} else if ( !context || context.jquery ) {
161
				return (context || rootjQuery).find( selector );
162
 
163
			// HANDLE: $(expr, context)
164
			// (which is just equivalent to: $(context).find(expr)
165
			} else {
166
				return jQuery( context ).find( selector );
167
			}
168
 
169
		// HANDLE: $(function)
170
		// Shortcut for document ready
171
		} else if ( jQuery.isFunction( selector ) ) {
172
			return rootjQuery.ready( selector );
173
		}
174
 
175
		if (selector.selector !== undefined) {
176
			this.selector = selector.selector;
177
			this.context = selector.context;
178
		}
179
 
180
		return jQuery.makeArray( selector, this );
181
	},
182
 
183
	// Start with an empty selector
184
	selector: "",
185
 
186
	// The current version of jQuery being used
187
	jquery: "1.4.2",
188
 
189
	// The default length of a jQuery object is 0
190
	length: 0,
191
 
192
	// The number of elements contained in the matched element set
193
	size: function() {
194
		return this.length;
195
	},
196
 
197
	toArray: function() {
198
		return slice.call( this, 0 );
199
	},
200
 
201
	// Get the Nth element in the matched element set OR
202
	// Get the whole matched element set as a clean array
203
	get: function( num ) {
204
		return num == null ?
205
 
206
			// Return a 'clean' array
207
			this.toArray() :
208
 
209
			// Return just the object
210
			( num < 0 ? this.slice(num)[ 0 ] : this[ num ] );
211
	},
212
 
213
	// Take an array of elements and push it onto the stack
214
	// (returning the new matched element set)
215
	pushStack: function( elems, name, selector ) {
216
		// Build a new jQuery matched element set
217
		var ret = jQuery();
218
 
219
		if ( jQuery.isArray( elems ) ) {
220
			push.apply( ret, elems );
221
 
222
		} else {
223
			jQuery.merge( ret, elems );
224
		}
225
 
226
		// Add the old object onto the stack (as a reference)
227
		ret.prevObject = this;
228
 
229
		ret.context = this.context;
230
 
231
		if ( name === "find" ) {
232
			ret.selector = this.selector + (this.selector ? " " : "") + selector;
233
		} else if ( name ) {
234
			ret.selector = this.selector + "." + name + "(" + selector + ")";
235
		}
236
 
237
		// Return the newly-formed element set
238
		return ret;
239
	},
240
 
241
	// Execute a callback for every element in the matched set.
242
	// (You can seed the arguments with an array of args, but this is
243
	// only used internally.)
244
	each: function( callback, args ) {
245
		return jQuery.each( this, callback, args );
246
	},
247
 
248
	ready: function( fn ) {
249
		// Attach the listeners
250
		jQuery.bindReady();
251
 
252
		// If the DOM is already ready
253
		if ( jQuery.isReady ) {
254
			// Execute the function immediately
255
			fn.call( document, jQuery );
256
 
257
		// Otherwise, remember the function for later
258
		} else if ( readyList ) {
259
			// Add the function to the wait list
260
			readyList.push( fn );
261
		}
262
 
263
		return this;
264
	},
265
 
266
	eq: function( i ) {
267
		return i === -1 ?
268
			this.slice( i ) :
269
			this.slice( i, +i + 1 );
270
	},
271
 
272
	first: function() {
273
		return this.eq( 0 );
274
	},
275
 
276
	last: function() {
277
		return this.eq( -1 );
278
	},
279
 
280
	slice: function() {
281
		return this.pushStack( slice.apply( this, arguments ),
282
			"slice", slice.call(arguments).join(",") );
283
	},
284
 
285
	map: function( callback ) {
286
		return this.pushStack( jQuery.map(this, function( elem, i ) {
287
			return callback.call( elem, i, elem );
288
		}));
289
	},
290
 
291
	end: function() {
292
		return this.prevObject || jQuery(null);
293
	},
294
 
295
	// For internal use only.
296
	// Behaves like an Array's method, not like a jQuery method.
297
	push: push,
298
	sort: [].sort,
299
	splice: [].splice
300
};
301
 
302
// Give the init function the jQuery prototype for later instantiation
303
jQuery.fn.init.prototype = jQuery.fn;
304
 
305
jQuery.extend = jQuery.fn.extend = function() {
306
	// copy reference to target object
307
	var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options, name, src, copy;
308
 
309
	// Handle a deep copy situation
310
	if ( typeof target === "boolean" ) {
311
		deep = target;
312
		target = arguments[1] || {};
313
		// skip the boolean and the target
314
		i = 2;
315
	}
316
 
317
	// Handle case when target is a string or something (possible in deep copy)
318
	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
319
		target = {};
320
	}
321
 
322
	// extend jQuery itself if only one argument is passed
323
	if ( length === i ) {
324
		target = this;
325
		--i;
326
	}
327
 
328
	for ( ; i < length; i++ ) {
329
		// Only deal with non-null/undefined values
330
		if ( (options = arguments[ i ]) != null ) {
331
			// Extend the base object
332
			for ( name in options ) {
333
				src = target[ name ];
334
				copy = options[ name ];
335
 
336
				// Prevent never-ending loop
337
				if ( target === copy ) {
338
					continue;
339
				}
340
 
341
				// Recurse if we're merging object literal values or arrays
342
				if ( deep && copy && ( jQuery.isPlainObject(copy) || jQuery.isArray(copy) ) ) {
343
					var clone = src && ( jQuery.isPlainObject(src) || jQuery.isArray(src) ) ? src
344
						: jQuery.isArray(copy) ? [] : {};
345
 
346
					// Never move original objects, clone them
347
					target[ name ] = jQuery.extend( deep, clone, copy );
348
 
349
				// Don't bring in undefined values
350
				} else if ( copy !== undefined ) {
351
					target[ name ] = copy;
352
				}
353
			}
354
		}
355
	}
356
 
357
	// Return the modified object
358
	return target;
359
};
360
 
361
jQuery.extend({
362
	noConflict: function( deep ) {
363
		window.$ = _$;
364
 
365
		if ( deep ) {
366
			window.jQuery = _jQuery;
367
		}
368
 
369
		return jQuery;
370
	},
371
 
372
	// Is the DOM ready to be used? Set to true once it occurs.
373
	isReady: false,
374
 
375
	// Handle when the DOM is ready
376
	ready: function() {
377
		// Make sure that the DOM is not already loaded
378
		if ( !jQuery.isReady ) {
379
			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
380
			if ( !document.body ) {
381
				return setTimeout( jQuery.ready, 13 );
382
			}
383
 
384
			// Remember that the DOM is ready
385
			jQuery.isReady = true;
386
 
387
			// If there are functions bound, to execute
388
			if ( readyList ) {
389
				// Execute all of them
390
				var fn, i = 0;
391
				while ( (fn = readyList[ i++ ]) ) {
392
					fn.call( document, jQuery );
393
				}
394
 
395
				// Reset the list of functions
396
				readyList = null;
397
			}
398
 
399
			// Trigger any bound ready events
400
			if ( jQuery.fn.triggerHandler ) {
401
				jQuery( document ).triggerHandler( "ready" );
402
			}
403
		}
404
	},
405
 
406
	bindReady: function() {
407
		if ( readyBound ) {
408
			return;
409
		}
410
 
411
		readyBound = true;
412
 
413
		// Catch cases where $(document).ready() is called after the
414
		// browser event has already occurred.
415
		if ( document.readyState === "complete" ) {
416
			return jQuery.ready();
417
		}
418
 
419
		// Mozilla, Opera and webkit nightlies currently support this event
420
		if ( document.addEventListener ) {
421
			// Use the handy event callback
422
			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
423
 
424
			// A fallback to window.onload, that will always work
425
			window.addEventListener( "load", jQuery.ready, false );
426
 
427
		// If IE event model is used
428
		} else if ( document.attachEvent ) {
429
			// ensure firing before onload,
430
			// maybe late but safe also for iframes
431
			document.attachEvent("onreadystatechange", DOMContentLoaded);
432
 
433
			// A fallback to window.onload, that will always work
434
			window.attachEvent( "onload", jQuery.ready );
435
 
436
			// If IE and not a frame
437
			// continually check to see if the document is ready
438
			var toplevel = false;
439
 
440
			try {
441
				toplevel = window.frameElement == null;
442
			} catch(e) {}
443
 
444
			if ( document.documentElement.doScroll && toplevel ) {
445
				doScrollCheck();
446
			}
447
		}
448
	},
449
 
450
	// See test/unit/core.js for details concerning isFunction.
451
	// Since version 1.3, DOM methods and functions like alert
452
	// aren't supported. They return false on IE (#2968).
453
	isFunction: function( obj ) {
454
		return toString.call(obj) === "[object Function]";
455
	},
456
 
457
	isArray: function( obj ) {
458
		return toString.call(obj) === "[object Array]";
459
	},
460
 
461
	isPlainObject: function( obj ) {
462
		// Must be an Object.
463
		// Because of IE, we also have to check the presence of the constructor property.
464
		// Make sure that DOM nodes and window objects don't pass through, as well
465
		if ( !obj || toString.call(obj) !== "[object Object]" || obj.nodeType || obj.setInterval ) {
466
			return false;
467
		}
468
 
469
		// Not own constructor property must be Object
470
		if ( obj.constructor
471
			&& !hasOwnProperty.call(obj, "constructor")
472
			&& !hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf") ) {
473
			return false;
474
		}
475
 
476
		// Own properties are enumerated firstly, so to speed up,
477
		// if last one is own, then all properties are own.
478
 
479
		var key;
480
		for ( key in obj ) {}
481
 
482
		return key === undefined || hasOwnProperty.call( obj, key );
483
	},
484
 
485
	isEmptyObject: function( obj ) {
486
		for ( var name in obj ) {
487
			return false;
488
		}
489
		return true;
490
	},
491
 
492
	error: function( msg ) {
493
		throw msg;
494
	},
495
 
496
	parseJSON: function( data ) {
497
		if ( typeof data !== "string" || !data ) {
498
			return null;
499
		}
500
 
501
		// Make sure leading/trailing whitespace is removed (IE can't handle it)
502
		data = jQuery.trim( data );
503
 
504
		// Make sure the incoming data is actual JSON
505
		// Logic borrowed from http://json.org/json2.js
506
		if ( /^[\],:{}\s]*$/.test(data.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, "@")
507
			.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]")
508
			.replace(/(?:^|:|,)(?:\s*\[)+/g, "")) ) {
509
 
510
			// Try to use the native JSON parser first
511
			return window.JSON && window.JSON.parse ?
512
				window.JSON.parse( data ) :
513
				(new Function("return " + data))();
514
 
515
		} else {
516
			jQuery.error( "Invalid JSON: " + data );
517
		}
518
	},
519
 
520
	noop: function() {},
521
 
522
	// Evalulates a script in a global context
523
	globalEval: function( data ) {
524
		if ( data && rnotwhite.test(data) ) {
525
			// Inspired by code by Andrea Giammarchi
526
			// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
527
			var head = document.getElementsByTagName("head")[0] || document.documentElement,
528
				script = document.createElement("script");
529
 
530
			script.type = "text/javascript";
531
 
532
			if ( jQuery.support.scriptEval ) {
533
				script.appendChild( document.createTextNode( data ) );
534
			} else {
535
				script.text = data;
536
			}
537
 
538
			// Use insertBefore instead of appendChild to circumvent an IE6 bug.
539
			// This arises when a base node is used (#2709).
540
			head.insertBefore( script, head.firstChild );
541
			head.removeChild( script );
542
		}
543
	},
544
 
545
	nodeName: function( elem, name ) {
546
		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
547
	},
548
 
549
	// args is for internal usage only
550
	each: function( object, callback, args ) {
551
		var name, i = 0,
552
			length = object.length,
553
			isObj = length === undefined || jQuery.isFunction(object);
554
 
555
		if ( args ) {
556
			if ( isObj ) {
557
				for ( name in object ) {
558
					if ( callback.apply( object[ name ], args ) === false ) {
559
						break;
560
					}
561
				}
562
			} else {
563
				for ( ; i < length; ) {
564
					if ( callback.apply( object[ i++ ], args ) === false ) {
565
						break;
566
					}
567
				}
568
			}
569
 
570
		// A special, fast, case for the most common use of each
571
		} else {
572
			if ( isObj ) {
573
				for ( name in object ) {
574
					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
575
						break;
576
					}
577
				}
578
			} else {
579
				for ( var value = object[0];
580
					i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
581
			}
582
		}
583
 
584
		return object;
585
	},
586
 
587
	trim: function( text ) {
588
		return (text || "").replace( rtrim, "" );
589
	},
590
 
591
	// results is for internal usage only
592
	makeArray: function( array, results ) {
593
		var ret = results || [];
594
 
595
		if ( array != null ) {
596
			// The window, strings (and functions) also have 'length'
597
			// The extra typeof function check is to prevent crashes
598
			// in Safari 2 (See: #3039)
599
			if ( array.length == null || typeof array === "string" || jQuery.isFunction(array) || (typeof array !== "function" && array.setInterval) ) {
600
				push.call( ret, array );
601
			} else {
602
				jQuery.merge( ret, array );
603
			}
604
		}
605
 
606
		return ret;
607
	},
608
 
609
	inArray: function( elem, array ) {
610
		if ( array.indexOf ) {
611
			return array.indexOf( elem );
612
		}
613
 
614
		for ( var i = 0, length = array.length; i < length; i++ ) {
615
			if ( array[ i ] === elem ) {
616
				return i;
617
			}
618
		}
619
 
620
		return -1;
621
	},
622
 
623
	merge: function( first, second ) {
624
		var i = first.length, j = 0;
625
 
626
		if ( typeof second.length === "number" ) {
627
			for ( var l = second.length; j < l; j++ ) {
628
				first[ i++ ] = second[ j ];
629
			}
630
 
631
		} else {
632
			while ( second[j] !== undefined ) {
633
				first[ i++ ] = second[ j++ ];
634
			}
635
		}
636
 
637
		first.length = i;
638
 
639
		return first;
640
	},
641
 
642
	grep: function( elems, callback, inv ) {
643
		var ret = [];
644
 
645
		// Go through the array, only saving the items
646
		// that pass the validator function
647
		for ( var i = 0, length = elems.length; i < length; i++ ) {
648
			if ( !inv !== !callback( elems[ i ], i ) ) {
649
				ret.push( elems[ i ] );
650
			}
651
		}
652
 
653
		return ret;
654
	},
655
 
656
	// arg is for internal usage only
657
	map: function( elems, callback, arg ) {
658
		var ret = [], value;
659
 
660
		// Go through the array, translating each of the items to their
661
		// new value (or values).
662
		for ( var i = 0, length = elems.length; i < length; i++ ) {
663
			value = callback( elems[ i ], i, arg );
664
 
665
			if ( value != null ) {
666
				ret[ ret.length ] = value;
667
			}
668
		}
669
 
670
		return ret.concat.apply( [], ret );
671
	},
672
 
673
	// A global GUID counter for objects
674
	guid: 1,
675
 
676
	proxy: function( fn, proxy, thisObject ) {
677
		if ( arguments.length === 2 ) {
678
			if ( typeof proxy === "string" ) {
679
				thisObject = fn;
680
				fn = thisObject[ proxy ];
681
				proxy = undefined;
682
 
683
			} else if ( proxy && !jQuery.isFunction( proxy ) ) {
684
				thisObject = proxy;
685
				proxy = undefined;
686
			}
687
		}
688
 
689
		if ( !proxy && fn ) {
690
			proxy = function() {
691
				return fn.apply( thisObject || this, arguments );
692
			};
693
		}
694
 
695
		// Set the guid of unique handler to the same of original handler, so it can be removed
696
		if ( fn ) {
697
			proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
698
		}
699
 
700
		// So proxy can be declared as an argument
701
		return proxy;
702
	},
703
 
704
	// Use of jQuery.browser is frowned upon.
705
	// More details: http://docs.jquery.com/Utilities/jQuery.browser
706
	uaMatch: function( ua ) {
707
		ua = ua.toLowerCase();
708
 
709
		var match = /(webkit)[ \/]([\w.]+)/.exec( ua ) ||
710
			/(opera)(?:.*version)?[ \/]([\w.]+)/.exec( ua ) ||
711
			/(msie) ([\w.]+)/.exec( ua ) ||
712
			!/compatible/.test( ua ) && /(mozilla)(?:.*? rv:([\w.]+))?/.exec( ua ) ||
713
		  	[];
714
 
715
		return { browser: match[1] || "", version: match[2] || "0" };
716
	},
717
 
718
	browser: {}
719
});
720
 
721
browserMatch = jQuery.uaMatch( userAgent );
722
if ( browserMatch.browser ) {
723
	jQuery.browser[ browserMatch.browser ] = true;
724
	jQuery.browser.version = browserMatch.version;
725
}
726
 
727
// Deprecated, use jQuery.browser.webkit instead
728
if ( jQuery.browser.webkit ) {
729
	jQuery.browser.safari = true;
730
}
731
 
732
if ( indexOf ) {
733
	jQuery.inArray = function( elem, array ) {
734
		return indexOf.call( array, elem );
735
	};
736
}
737
 
738
// All jQuery objects should point back to these
739
rootjQuery = jQuery(document);
740
 
741
// Cleanup functions for the document ready method
742
if ( document.addEventListener ) {
743
	DOMContentLoaded = function() {
744
		document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
745
		jQuery.ready();
746
	};
747
 
748
} else if ( document.attachEvent ) {
749
	DOMContentLoaded = function() {
750
		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
751
		if ( document.readyState === "complete" ) {
752
			document.detachEvent( "onreadystatechange", DOMContentLoaded );
753
			jQuery.ready();
754
		}
755
	};
756
}
757
 
758
// The DOM ready check for Internet Explorer
759
function doScrollCheck() {
760
	if ( jQuery.isReady ) {
761
		return;
762
	}
763
 
764
	try {
765
		// If IE is used, use the trick by Diego Perini
766
		// http://javascript.nwbox.com/IEContentLoaded/
767
		document.documentElement.doScroll("left");
768
	} catch( error ) {
769
		setTimeout( doScrollCheck, 1 );
770
		return;
771
	}
772
 
773
	// and execute any waiting functions
774
	jQuery.ready();
775
}
776
 
777
function evalScript( i, elem ) {
778
	if ( elem.src ) {
779
		jQuery.ajax({
780
			url: elem.src,
781
			async: false,
782
			dataType: "script"
783
		});
784
	} else {
785
		jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
786
	}
787
 
788
	if ( elem.parentNode ) {
789
		elem.parentNode.removeChild( elem );
790
	}
791
}
792
 
793
// Mutifunctional method to get and set values to a collection
794
// The value/s can be optionally by executed if its a function
795
function access( elems, key, value, exec, fn, pass ) {
796
	var length = elems.length;
797
 
798
	// Setting many attributes
799
	if ( typeof key === "object" ) {
800
		for ( var k in key ) {
801
			access( elems, k, key[k], exec, fn, value );
802
		}
803
		return elems;
804
	}
805
 
806
	// Setting one attribute
807
	if ( value !== undefined ) {
808
		// Optionally, function values get executed if exec is true
809
		exec = !pass && exec && jQuery.isFunction(value);
810
 
811
		for ( var i = 0; i < length; i++ ) {
812
			fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
813
		}
814
 
815
		return elems;
816
	}
817
 
818
	// Getting an attribute
819
	return length ? fn( elems[0], key ) : undefined;
820
}
821
 
822
function now() {
823
	return (new Date).getTime();
824
}
825
(function() {
826
 
827
	jQuery.support = {};
828
 
829
	var root = document.documentElement,
830
		script = document.createElement("script"),
831
		div = document.createElement("div"),
832
		id = "script" + now();
833
 
834
	div.style.display = "none";
835
	div.innerHTML = "   <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
836
 
837
	var all = div.getElementsByTagName("*"),
838
		a = div.getElementsByTagName("a")[0];
839
 
840
	// Can't get basic test support
841
	if ( !all || !all.length || !a ) {
842
		return;
843
	}
844
 
845
	jQuery.support = {
846
		// IE strips leading whitespace when .innerHTML is used
847
		leadingWhitespace: div.firstChild.nodeType === 3,
848
 
849
		// Make sure that tbody elements aren't automatically inserted
850
		// IE will insert them into empty tables
851
		tbody: !div.getElementsByTagName("tbody").length,
852
 
853
		// Make sure that link elements get serialized correctly by innerHTML
854
		// This requires a wrapper element in IE
855
		htmlSerialize: !!div.getElementsByTagName("link").length,
856
 
857
		// Get the style information from getAttribute
858
		// (IE uses .cssText insted)
859
		style: /red/.test( a.getAttribute("style") ),
860
 
861
		// Make sure that URLs aren't manipulated
862
		// (IE normalizes it by default)
863
		hrefNormalized: a.getAttribute("href") === "/a",
864
 
865
		// Make sure that element opacity exists
866
		// (IE uses filter instead)
867
		// Use a regex to work around a WebKit issue. See #5145
868
		opacity: /^0.55$/.test( a.style.opacity ),
869
 
870
		// Verify style float existence
871
		// (IE uses styleFloat instead of cssFloat)
872
		cssFloat: !!a.style.cssFloat,
873
 
874
		// Make sure that if no value is specified for a checkbox
875
		// that it defaults to "on".
876
		// (WebKit defaults to "" instead)
877
		checkOn: div.getElementsByTagName("input")[0].value === "on",
878
 
879
		// Make sure that a selected-by-default option has a working selected property.
880
		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
881
		optSelected: document.createElement("select").appendChild( document.createElement("option") ).selected,
882
 
883
		parentNode: div.removeChild( div.appendChild( document.createElement("div") ) ).parentNode === null,
884
 
885
		// Will be defined later
886
		deleteExpando: true,
887
		checkClone: false,
888
		scriptEval: false,
889
		noCloneEvent: true,
890
		boxModel: null
891
	};
892
 
893
	script.type = "text/javascript";
894
	try {
895
		script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
896
	} catch(e) {}
897
 
898
	root.insertBefore( script, root.firstChild );
899
 
900
	// Make sure that the execution of code works by injecting a script
901
	// tag with appendChild/createTextNode
902
	// (IE doesn't support this, fails, and uses .text instead)
903
	if ( window[ id ] ) {
904
		jQuery.support.scriptEval = true;
905
		delete window[ id ];
906
	}
907
 
908
	// Test to see if it's possible to delete an expando from an element
909
	// Fails in Internet Explorer
910
	try {
911
		delete script.test;
912
 
913
	} catch(e) {
914
		jQuery.support.deleteExpando = false;
915
	}
916
 
917
	root.removeChild( script );
918
 
919
	if ( div.attachEvent && div.fireEvent ) {
920
		div.attachEvent("onclick", function click() {
921
			// Cloning a node shouldn't copy over any
922
			// bound event handlers (IE does this)
923
			jQuery.support.noCloneEvent = false;
924
			div.detachEvent("onclick", click);
925
		});
926
		div.cloneNode(true).fireEvent("onclick");
927
	}
928
 
929
	div = document.createElement("div");
930
	div.innerHTML = "<input type='radio' name='radiotest' checked='checked'/>";
931
 
932
	var fragment = document.createDocumentFragment();
933
	fragment.appendChild( div.firstChild );
934
 
935
	// WebKit doesn't clone checked state correctly in fragments
936
	jQuery.support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
937
 
938
	// Figure out if the W3C box model works as expected
939
	// document.body must exist before we can do this
940
	jQuery(function() {
941
		var div = document.createElement("div");
942
		div.style.width = div.style.paddingLeft = "1px";
943
 
944
		document.body.appendChild( div );
945
		jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
946
		document.body.removeChild( div ).style.display = 'none';
947
 
948
		div = null;
949
	});
950
 
951
	// Technique from Juriy Zaytsev
952
	// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
953
	var eventSupported = function( eventName ) {
954
		var el = document.createElement("div");
955
		eventName = "on" + eventName;
956
 
957
		var isSupported = (eventName in el);
958
		if ( !isSupported ) {
959
			el.setAttribute(eventName, "return;");
960
			isSupported = typeof el[eventName] === "function";
961
		}
962
		el = null;
963
 
964
		return isSupported;
965
	};
966
 
967
	jQuery.support.submitBubbles = eventSupported("submit");
968
	jQuery.support.changeBubbles = eventSupported("change");
969
 
970
	// release memory in IE
971
	root = script = div = all = a = null;
972
})();
973
 
974
jQuery.props = {
975
	"for": "htmlFor",
976
	"class": "className",
977
	readonly: "readOnly",
978
	maxlength: "maxLength",
979
	cellspacing: "cellSpacing",
980
	rowspan: "rowSpan",
981
	colspan: "colSpan",
982
	tabindex: "tabIndex",
983
	usemap: "useMap",
984
	frameborder: "frameBorder"
985
};
986
var expando = "jQuery" + now(), uuid = 0, windowData = {};
987
 
988
jQuery.extend({
989
	cache: {},
990
 
991
	expando:expando,
992
 
993
	// The following elements throw uncatchable exceptions if you
994
	// attempt to add expando properties to them.
995
	noData: {
996
		"embed": true,
997
		"object": true,
998
		"applet": true
999
	},
1000
 
1001
	data: function( elem, name, data ) {
1002
		if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
1003
			return;
1004
		}
1005
 
1006
		elem = elem == window ?
1007
			windowData :
1008
			elem;
1009
 
1010
		var id = elem[ expando ], cache = jQuery.cache, thisCache;
1011
 
1012
		if ( !id && typeof name === "string" && data === undefined ) {
1013
			return null;
1014
		}
1015
 
1016
		// Compute a unique ID for the element
1017
		if ( !id ) {
1018
			id = ++uuid;
1019
		}
1020
 
1021
		// Avoid generating a new cache unless none exists and we
1022
		// want to manipulate it.
1023
		if ( typeof name === "object" ) {
1024
			elem[ expando ] = id;
1025
			thisCache = cache[ id ] = jQuery.extend(true, {}, name);
1026
 
1027
		} else if ( !cache[ id ] ) {
1028
			elem[ expando ] = id;
1029
			cache[ id ] = {};
1030
		}
1031
 
1032
		thisCache = cache[ id ];
1033
 
1034
		// Prevent overriding the named cache with undefined values
1035
		if ( data !== undefined ) {
1036
			thisCache[ name ] = data;
1037
		}
1038
 
1039
		return typeof name === "string" ? thisCache[ name ] : thisCache;
1040
	},
1041
 
1042
	removeData: function( elem, name ) {
1043
		if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
1044
			return;
1045
		}
1046
 
1047
		elem = elem == window ?
1048
			windowData :
1049
			elem;
1050
 
1051
		var id = elem[ expando ], cache = jQuery.cache, thisCache = cache[ id ];
1052
 
1053
		// If we want to remove a specific section of the element's data
1054
		if ( name ) {
1055
			if ( thisCache ) {
1056
				// Remove the section of cache data
1057
				delete thisCache[ name ];
1058
 
1059
				// If we've removed all the data, remove the element's cache
1060
				if ( jQuery.isEmptyObject(thisCache) ) {
1061
					jQuery.removeData( elem );
1062
				}
1063
			}
1064
 
1065
		// Otherwise, we want to remove all of the element's data
1066
		} else {
1067
			if ( jQuery.support.deleteExpando ) {
1068
				delete elem[ jQuery.expando ];
1069
 
1070
			} else if ( elem.removeAttribute ) {
1071
				elem.removeAttribute( jQuery.expando );
1072
			}
1073
 
1074
			// Completely remove the data cache
1075
			delete cache[ id ];
1076
		}
1077
	}
1078
});
1079
 
1080
jQuery.fn.extend({
1081
	data: function( key, value ) {
1082
		if ( typeof key === "undefined" && this.length ) {
1083
			return jQuery.data( this[0] );
1084
 
1085
		} else if ( typeof key === "object" ) {
1086
			return this.each(function() {
1087
				jQuery.data( this, key );
1088
			});
1089
		}
1090
 
1091
		var parts = key.split(".");
1092
		parts[1] = parts[1] ? "." + parts[1] : "";
1093
 
1094
		if ( value === undefined ) {
1095
			var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1096
 
1097
			if ( data === undefined && this.length ) {
1098
				data = jQuery.data( this[0], key );
1099
			}
1100
			return data === undefined && parts[1] ?
1101
				this.data( parts[0] ) :
1102
				data;
1103
		} else {
1104
			return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function() {
1105
				jQuery.data( this, key, value );
1106
			});
1107
		}
1108
	},
1109
 
1110
	removeData: function( key ) {
1111
		return this.each(function() {
1112
			jQuery.removeData( this, key );
1113
		});
1114
	}
1115
});
1116
jQuery.extend({
1117
	queue: function( elem, type, data ) {
1118
		if ( !elem ) {
1119
			return;
1120
		}
1121
 
1122
		type = (type || "fx") + "queue";
1123
		var q = jQuery.data( elem, type );
1124
 
1125
		// Speed up dequeue by getting out quickly if this is just a lookup
1126
		if ( !data ) {
1127
			return q || [];
1128
		}
1129
 
1130
		if ( !q || jQuery.isArray(data) ) {
1131
			q = jQuery.data( elem, type, jQuery.makeArray(data) );
1132
 
1133
		} else {
1134
			q.push( data );
1135
		}
1136
 
1137
		return q;
1138
	},
1139
 
1140
	dequeue: function( elem, type ) {
1141
		type = type || "fx";
1142
 
1143
		var queue = jQuery.queue( elem, type ), fn = queue.shift();
1144
 
1145
		// If the fx queue is dequeued, always remove the progress sentinel
1146
		if ( fn === "inprogress" ) {
1147
			fn = queue.shift();
1148
		}
1149
 
1150
		if ( fn ) {
1151
			// Add a progress sentinel to prevent the fx queue from being
1152
			// automatically dequeued
1153
			if ( type === "fx" ) {
1154
				queue.unshift("inprogress");
1155
			}
1156
 
1157
			fn.call(elem, function() {
1158
				jQuery.dequeue(elem, type);
1159
			});
1160
		}
1161
	}
1162
});
1163
 
1164
jQuery.fn.extend({
1165
	queue: function( type, data ) {
1166
		if ( typeof type !== "string" ) {
1167
			data = type;
1168
			type = "fx";
1169
		}
1170
 
1171
		if ( data === undefined ) {
1172
			return jQuery.queue( this[0], type );
1173
		}
1174
		return this.each(function( i, elem ) {
1175
			var queue = jQuery.queue( this, type, data );
1176
 
1177
			if ( type === "fx" && queue[0] !== "inprogress" ) {
1178
				jQuery.dequeue( this, type );
1179
			}
1180
		});
1181
	},
1182
	dequeue: function( type ) {
1183
		return this.each(function() {
1184
			jQuery.dequeue( this, type );
1185
		});
1186
	},
1187
 
1188
	// Based off of the plugin by Clint Helfers, with permission.
1189
	// http://blindsignals.com/index.php/2009/07/jquery-delay/
1190
	delay: function( time, type ) {
1191
		time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1192
		type = type || "fx";
1193
 
1194
		return this.queue( type, function() {
1195
			var elem = this;
1196
			setTimeout(function() {
1197
				jQuery.dequeue( elem, type );
1198
			}, time );
1199
		});
1200
	},
1201
 
1202
	clearQueue: function( type ) {
1203
		return this.queue( type || "fx", [] );
1204
	}
1205
});
1206
var rclass = /[\n\t]/g,
1207
	rspace = /\s+/,
1208
	rreturn = /\r/g,
1209
	rspecialurl = /href|src|style/,
1210
	rtype = /(button|input)/i,
1211
	rfocusable = /(button|input|object|select|textarea)/i,
1212
	rclickable = /^(a|area)$/i,
1213
	rradiocheck = /radio|checkbox/;
1214
 
1215
jQuery.fn.extend({
1216
	attr: function( name, value ) {
1217
		return access( this, name, value, true, jQuery.attr );
1218
	},
1219
 
1220
	removeAttr: function( name, fn ) {
1221
		return this.each(function(){
1222
			jQuery.attr( this, name, "" );
1223
			if ( this.nodeType === 1 ) {
1224
				this.removeAttribute( name );
1225
			}
1226
		});
1227
	},
1228
 
1229
	addClass: function( value ) {
1230
		if ( jQuery.isFunction(value) ) {
1231
			return this.each(function(i) {
1232
				var self = jQuery(this);
1233
				self.addClass( value.call(this, i, self.attr("class")) );
1234
			});
1235
		}
1236
 
1237
		if ( value && typeof value === "string" ) {
1238
			var classNames = (value || "").split( rspace );
1239
 
1240
			for ( var i = 0, l = this.length; i < l; i++ ) {
1241
				var elem = this[i];
1242
 
1243
				if ( elem.nodeType === 1 ) {
1244
					if ( !elem.className ) {
1245
						elem.className = value;
1246
 
1247
					} else {
1248
						var className = " " + elem.className + " ", setClass = elem.className;
1249
						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1250
							if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
1251
								setClass += " " + classNames[c];
1252
							}
1253
						}
1254
						elem.className = jQuery.trim( setClass );
1255
					}
1256
				}
1257
			}
1258
		}
1259
 
1260
		return this;
1261
	},
1262
 
1263
	removeClass: function( value ) {
1264
		if ( jQuery.isFunction(value) ) {
1265
			return this.each(function(i) {
1266
				var self = jQuery(this);
1267
				self.removeClass( value.call(this, i, self.attr("class")) );
1268
			});
1269
		}
1270
 
1271
		if ( (value && typeof value === "string") || value === undefined ) {
1272
			var classNames = (value || "").split(rspace);
1273
 
1274
			for ( var i = 0, l = this.length; i < l; i++ ) {
1275
				var elem = this[i];
1276
 
1277
				if ( elem.nodeType === 1 && elem.className ) {
1278
					if ( value ) {
1279
						var className = (" " + elem.className + " ").replace(rclass, " ");
1280
						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1281
							className = className.replace(" " + classNames[c] + " ", " ");
1282
						}
1283
						elem.className = jQuery.trim( className );
1284
 
1285
					} else {
1286
						elem.className = "";
1287
					}
1288
				}
1289
			}
1290
		}
1291
 
1292
		return this;
1293
	},
1294
 
1295
	toggleClass: function( value, stateVal ) {
1296
		var type = typeof value, isBool = typeof stateVal === "boolean";
1297
 
1298
		if ( jQuery.isFunction( value ) ) {
1299
			return this.each(function(i) {
1300
				var self = jQuery(this);
1301
				self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
1302
			});
1303
		}
1304
 
1305
		return this.each(function() {
1306
			if ( type === "string" ) {
1307
				// toggle individual class names
1308
				var className, i = 0, self = jQuery(this),
1309
					state = stateVal,
1310
					classNames = value.split( rspace );
1311
 
1312
				while ( (className = classNames[ i++ ]) ) {
1313
					// check each className given, space seperated list
1314
					state = isBool ? state : !self.hasClass( className );
1315
					self[ state ? "addClass" : "removeClass" ]( className );
1316
				}
1317
 
1318
			} else if ( type === "undefined" || type === "boolean" ) {
1319
				if ( this.className ) {
1320
					// store className if set
1321
					jQuery.data( this, "__className__", this.className );
1322
				}
1323
 
1324
				// toggle whole className
1325
				this.className = this.className || value === false ? "" : jQuery.data( this, "__className__" ) || "";
1326
			}
1327
		});
1328
	},
1329
 
1330
	hasClass: function( selector ) {
1331
		var className = " " + selector + " ";
1332
		for ( var i = 0, l = this.length; i < l; i++ ) {
1333
			if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
1334
				return true;
1335
			}
1336
		}
1337
 
1338
		return false;
1339
	},
1340
 
1341
	val: function( value ) {
1342
		if ( value === undefined ) {
1343
			var elem = this[0];
1344
 
1345
			if ( elem ) {
1346
				if ( jQuery.nodeName( elem, "option" ) ) {
1347
					return (elem.attributes.value || {}).specified ? elem.value : elem.text;
1348
				}
1349
 
1350
				// We need to handle select boxes special
1351
				if ( jQuery.nodeName( elem, "select" ) ) {
1352
					var index = elem.selectedIndex,
1353
						values = [],
1354
						options = elem.options,
1355
						one = elem.type === "select-one";
1356
 
1357
					// Nothing was selected
1358
					if ( index < 0 ) {
1359
						return null;
1360
					}
1361
 
1362
					// Loop through all the selected options
1363
					for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
1364
						var option = options[ i ];
1365
 
1366
						if ( option.selected ) {
1367
							// Get the specifc value for the option
1368
							value = jQuery(option).val();
1369
 
1370
							// We don't need an array for one selects
1371
							if ( one ) {
1372
								return value;
1373
							}
1374
 
1375
							// Multi-Selects return an array
1376
							values.push( value );
1377
						}
1378
					}
1379
 
1380
					return values;
1381
				}
1382
 
1383
				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
1384
				if ( rradiocheck.test( elem.type ) && !jQuery.support.checkOn ) {
1385
					return elem.getAttribute("value") === null ? "on" : elem.value;
1386
				}
1387
 
1388
 
1389
				// Everything else, we just grab the value
1390
				return (elem.value || "").replace(rreturn, "");
1391
 
1392
			}
1393
 
1394
			return undefined;
1395
		}
1396
 
1397
		var isFunction = jQuery.isFunction(value);
1398
 
1399
		return this.each(function(i) {
1400
			var self = jQuery(this), val = value;
1401
 
1402
			if ( this.nodeType !== 1 ) {
1403
				return;
1404
			}
1405
 
1406
			if ( isFunction ) {
1407
				val = value.call(this, i, self.val());
1408
			}
1409
 
1410
			// Typecast each time if the value is a Function and the appended
1411
			// value is therefore different each time.
1412
			if ( typeof val === "number" ) {
1413
				val += "";
1414
			}
1415
 
1416
			if ( jQuery.isArray(val) && rradiocheck.test( this.type ) ) {
1417
				this.checked = jQuery.inArray( self.val(), val ) >= 0;
1418
 
1419
			} else if ( jQuery.nodeName( this, "select" ) ) {
1420
				var values = jQuery.makeArray(val);
1421
 
1422
				jQuery( "option", this ).each(function() {
1423
					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
1424
				});
1425
 
1426
				if ( !values.length ) {
1427
					this.selectedIndex = -1;
1428
				}
1429
 
1430
			} else {
1431
				this.value = val;
1432
			}
1433
		});
1434
	}
1435
});
1436
 
1437
jQuery.extend({
1438
	attrFn: {
1439
		val: true,
1440
		css: true,
1441
		html: true,
1442
		text: true,
1443
		data: true,
1444
		width: true,
1445
		height: true,
1446
		offset: true
1447
	},
1448
 
1449
	attr: function( elem, name, value, pass ) {
1450
		// don't set attributes on text and comment nodes
1451
		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
1452
			return undefined;
1453
		}
1454
 
1455
		if ( pass && name in jQuery.attrFn ) {
1456
			return jQuery(elem)[name](value);
1457
		}
1458
 
1459
		var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
1460
			// Whether we are setting (or getting)
1461
			set = value !== undefined;
1462
 
1463
		// Try to normalize/fix the name
1464
		name = notxml && jQuery.props[ name ] || name;
1465
 
1466
		// Only do all the following if this is a node (faster for style)
1467
		if ( elem.nodeType === 1 ) {
1468
			// These attributes require special treatment
1469
			var special = rspecialurl.test( name );
1470
 
1471
			// Safari mis-reports the default selected property of an option
1472
			// Accessing the parent's selectedIndex property fixes it
1473
			if ( name === "selected" && !jQuery.support.optSelected ) {
1474
				var parent = elem.parentNode;
1475
				if ( parent ) {
1476
					parent.selectedIndex;
1477
 
1478
					// Make sure that it also works with optgroups, see #5701
1479
					if ( parent.parentNode ) {
1480
						parent.parentNode.selectedIndex;
1481
					}
1482
				}
1483
			}
1484
 
1485
			// If applicable, access the attribute via the DOM 0 way
1486
			if ( name in elem && notxml && !special ) {
1487
				if ( set ) {
1488
					// We can't allow the type property to be changed (since it causes problems in IE)
1489
					if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
1490
						jQuery.error( "type property can't be changed" );
1491
					}
1492
 
1493
					elem[ name ] = value;
1494
				}
1495
 
1496
				// browsers index elements by id/name on forms, give priority to attributes.
1497
				if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
1498
					return elem.getAttributeNode( name ).nodeValue;
1499
				}
1500
 
1501
				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
1502
				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
1503
				if ( name === "tabIndex" ) {
1504
					var attributeNode = elem.getAttributeNode( "tabIndex" );
1505
 
1506
					return attributeNode && attributeNode.specified ?
1507
						attributeNode.value :
1508
						rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
1509
 
1510
							undefined;
1511
				}
1512
 
1513
				return elem[ name ];
1514
			}
1515
 
1516
			if ( !jQuery.support.style && notxml && name === "style" ) {
1517
				if ( set ) {
1518
					elem.style.cssText = "" + value;
1519
				}
1520
 
1521
				return elem.style.cssText;
1522
			}
1523
 
1524
			if ( set ) {
1525
				// convert the value to a string (all browsers do this but IE) see #1070
1526
				elem.setAttribute( name, "" + value );
1527
			}
1528
 
1529
			var attr = !jQuery.support.hrefNormalized && notxml && special ?
1530
					// Some attributes require a special call on IE
1531
					elem.getAttribute( name, 2 ) :
1532
					elem.getAttribute( name );
1533
 
1534
			// Non-existent attributes return null, we normalize to undefined
1535
			return attr === null ? undefined : attr;
1536
		}
1537
 
1538
		// elem is actually elem.style ... set the style
1539
		// Using attr for specific style information is now deprecated. Use style instead.
1540
		return jQuery.style( elem, name, value );
1541
	}
1542
});
1543
var rnamespaces = /\.(.*)$/,
1544
	fcleanup = function( nm ) {
1545
		return nm.replace(/[^\w\s\.\|`]/g, function( ch ) {
1546
			return "\\" + ch;
1547
		});
1548
	};
1549
 
1550
/*
1551
 * A number of helper functions used for managing events.
1552
 * Many of the ideas behind this code originated from
1553
 * Dean Edwards' addEvent library.
1554
 */
1555
jQuery.event = {
1556
 
1557
	// Bind an event to an element
1558
	// Original by Dean Edwards
1559
	add: function( elem, types, handler, data ) {
1560
		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
1561
			return;
1562
		}
1563
 
1564
		// For whatever reason, IE has trouble passing the window object
1565
		// around, causing it to be cloned in the process
1566
		if ( elem.setInterval && ( elem !== window && !elem.frameElement ) ) {
1567
			elem = window;
1568
		}
1569
 
1570
		var handleObjIn, handleObj;
1571
 
1572
		if ( handler.handler ) {
1573
			handleObjIn = handler;
1574
			handler = handleObjIn.handler;
1575
		}
1576
 
1577
		// Make sure that the function being executed has a unique ID
1578
		if ( !handler.guid ) {
1579
			handler.guid = jQuery.guid++;
1580
		}
1581
 
1582
		// Init the element's event structure
1583
		var elemData = jQuery.data( elem );
1584
 
1585
		// If no elemData is found then we must be trying to bind to one of the
1586
		// banned noData elements
1587
		if ( !elemData ) {
1588
			return;
1589
		}
1590
 
1591
		var events = elemData.events = elemData.events || {},
1592
			eventHandle = elemData.handle, eventHandle;
1593
 
1594
		if ( !eventHandle ) {
1595
			elemData.handle = eventHandle = function() {
1596
				// Handle the second event of a trigger and when
1597
				// an event is called after a page has unloaded
1598
				return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
1599
					jQuery.event.handle.apply( eventHandle.elem, arguments ) :
1600
					undefined;
1601
			};
1602
		}
1603
 
1604
		// Add elem as a property of the handle function
1605
		// This is to prevent a memory leak with non-native events in IE.
1606
		eventHandle.elem = elem;
1607
 
1608
		// Handle multiple events separated by a space
1609
		// jQuery(...).bind("mouseover mouseout", fn);
1610
		types = types.split(" ");
1611
 
1612
		var type, i = 0, namespaces;
1613
 
1614
		while ( (type = types[ i++ ]) ) {
1615
			handleObj = handleObjIn ?
1616
				jQuery.extend({}, handleObjIn) :
1617
				{ handler: handler, data: data };
1618
 
1619
			// Namespaced event handlers
1620
			if ( type.indexOf(".") > -1 ) {
1621
				namespaces = type.split(".");
1622
				type = namespaces.shift();
1623
				handleObj.namespace = namespaces.slice(0).sort().join(".");
1624
 
1625
			} else {
1626
				namespaces = [];
1627
				handleObj.namespace = "";
1628
			}
1629
 
1630
			handleObj.type = type;
1631
			handleObj.guid = handler.guid;
1632
 
1633
			// Get the current list of functions bound to this event
1634
			var handlers = events[ type ],
1635
				special = jQuery.event.special[ type ] || {};
1636
 
1637
			// Init the event handler queue
1638
			if ( !handlers ) {
1639
				handlers = events[ type ] = [];
1640
 
1641
				// Check for a special event handler
1642
				// Only use addEventListener/attachEvent if the special
1643
				// events handler returns false
1644
				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
1645
					// Bind the global event handler to the element
1646
					if ( elem.addEventListener ) {
1647
						elem.addEventListener( type, eventHandle, false );
1648
 
1649
					} else if ( elem.attachEvent ) {
1650
						elem.attachEvent( "on" + type, eventHandle );
1651
					}
1652
				}
1653
			}
1654
 
1655
			if ( special.add ) {
1656
				special.add.call( elem, handleObj );
1657
 
1658
				if ( !handleObj.handler.guid ) {
1659
					handleObj.handler.guid = handler.guid;
1660
				}
1661
			}
1662
 
1663
			// Add the function to the element's handler list
1664
			handlers.push( handleObj );
1665
 
1666
			// Keep track of which events have been used, for global triggering
1667
			jQuery.event.global[ type ] = true;
1668
		}
1669
 
1670
		// Nullify elem to prevent memory leaks in IE
1671
		elem = null;
1672
	},
1673
 
1674
	global: {},
1675
 
1676
	// Detach an event or set of events from an element
1677
	remove: function( elem, types, handler, pos ) {
1678
		// don't do events on text and comment nodes
1679
		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
1680
			return;
1681
		}
1682
 
1683
		var ret, type, fn, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
1684
			elemData = jQuery.data( elem ),
1685
			events = elemData && elemData.events;
1686
 
1687
		if ( !elemData || !events ) {
1688
			return;
1689
		}
1690
 
1691
		// types is actually an event object here
1692
		if ( types && types.type ) {
1693
			handler = types.handler;
1694
			types = types.type;
1695
		}
1696
 
1697
		// Unbind all events for the element
1698
		if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
1699
			types = types || "";
1700
 
1701
			for ( type in events ) {
1702
				jQuery.event.remove( elem, type + types );
1703
			}
1704
 
1705
			return;
1706
		}
1707
 
1708
		// Handle multiple events separated by a space
1709
		// jQuery(...).unbind("mouseover mouseout", fn);
1710
		types = types.split(" ");
1711
 
1712
		while ( (type = types[ i++ ]) ) {
1713
			origType = type;
1714
			handleObj = null;
1715
			all = type.indexOf(".") < 0;
1716
			namespaces = [];
1717
 
1718
			if ( !all ) {
1719
				// Namespaced event handlers
1720
				namespaces = type.split(".");
1721
				type = namespaces.shift();
1722
 
1723
				namespace = new RegExp("(^|\\.)" +
1724
					jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)")
1725
			}
1726
 
1727
			eventType = events[ type ];
1728
 
1729
			if ( !eventType ) {
1730
				continue;
1731
			}
1732
 
1733
			if ( !handler ) {
1734
				for ( var j = 0; j < eventType.length; j++ ) {
1735
					handleObj = eventType[ j ];
1736
 
1737
					if ( all || namespace.test( handleObj.namespace ) ) {
1738
						jQuery.event.remove( elem, origType, handleObj.handler, j );
1739
						eventType.splice( j--, 1 );
1740
					}
1741
				}
1742
 
1743
				continue;
1744
			}
1745
 
1746
			special = jQuery.event.special[ type ] || {};
1747
 
1748
			for ( var j = pos || 0; j < eventType.length; j++ ) {
1749
				handleObj = eventType[ j ];
1750
 
1751
				if ( handler.guid === handleObj.guid ) {
1752
					// remove the given handler for the given type
1753
					if ( all || namespace.test( handleObj.namespace ) ) {
1754
						if ( pos == null ) {
1755
							eventType.splice( j--, 1 );
1756
						}
1757
 
1758
						if ( special.remove ) {
1759
							special.remove.call( elem, handleObj );
1760
						}
1761
					}
1762
 
1763
					if ( pos != null ) {
1764
						break;
1765
					}
1766
				}
1767
			}
1768
 
1769
			// remove generic event handler if no more handlers exist
1770
			if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
1771
				if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
1772
					removeEvent( elem, type, elemData.handle );
1773
				}
1774
 
1775
				ret = null;
1776
				delete events[ type ];
1777
			}
1778
		}
1779
 
1780
		// Remove the expando if it's no longer used
1781
		if ( jQuery.isEmptyObject( events ) ) {
1782
			var handle = elemData.handle;
1783
			if ( handle ) {
1784
				handle.elem = null;
1785
			}
1786
 
1787
			delete elemData.events;
1788
			delete elemData.handle;
1789
 
1790
			if ( jQuery.isEmptyObject( elemData ) ) {
1791
				jQuery.removeData( elem );
1792
			}
1793
		}
1794
	},
1795
 
1796
	// bubbling is internal
1797
	trigger: function( event, data, elem /*, bubbling */ ) {
1798
		// Event object or event type
1799
		var type = event.type || event,
1800
			bubbling = arguments[3];
1801
 
1802
		if ( !bubbling ) {
1803
			event = typeof event === "object" ?
1804
				// jQuery.Event object
1805
				event[expando] ? event :
1806
				// Object literal
1807
				jQuery.extend( jQuery.Event(type), event ) :
1808
				// Just the event type (string)
1809
				jQuery.Event(type);
1810
 
1811
			if ( type.indexOf("!") >= 0 ) {
1812
				event.type = type = type.slice(0, -1);
1813
				event.exclusive = true;
1814
			}
1815
 
1816
			// Handle a global trigger
1817
			if ( !elem ) {
1818
				// Don't bubble custom events when global (to avoid too much overhead)
1819
				event.stopPropagation();
1820
 
1821
				// Only trigger if we've ever bound an event for it
1822
				if ( jQuery.event.global[ type ] ) {
1823
					jQuery.each( jQuery.cache, function() {
1824
						if ( this.events && this.events[type] ) {
1825
							jQuery.event.trigger( event, data, this.handle.elem );
1826
						}
1827
					});
1828
				}
1829
			}
1830
 
1831
			// Handle triggering a single element
1832
 
1833
			// don't do events on text and comment nodes
1834
			if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
1835
				return undefined;
1836
			}
1837
 
1838
			// Clean up in case it is reused
1839
			event.result = undefined;
1840
			event.target = elem;
1841
 
1842
			// Clone the incoming data, if any
1843
			data = jQuery.makeArray( data );
1844
			data.unshift( event );
1845
		}
1846
 
1847
		event.currentTarget = elem;
1848
 
1849
		// Trigger the event, it is assumed that "handle" is a function
1850
		var handle = jQuery.data( elem, "handle" );
1851
		if ( handle ) {
1852
			handle.apply( elem, data );
1853
		}
1854
 
1855
		var parent = elem.parentNode || elem.ownerDocument;
1856
 
1857
		// Trigger an inline bound script
1858
		try {
1859
			if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) {
1860
				if ( elem[ "on" + type ] && elem[ "on" + type ].apply( elem, data ) === false ) {
1861
					event.result = false;
1862
				}
1863
			}
1864
 
1865
		// prevent IE from throwing an error for some elements with some event types, see #3533
1866
		} catch (e) {}
1867
 
1868
		if ( !event.isPropagationStopped() && parent ) {
1869
			jQuery.event.trigger( event, data, parent, true );
1870
 
1871
		} else if ( !event.isDefaultPrevented() ) {
1872
			var target = event.target, old,
1873
				isClick = jQuery.nodeName(target, "a") && type === "click",
1874
				special = jQuery.event.special[ type ] || {};
1875
 
1876
			if ( (!special._default || special._default.call( elem, event ) === false) &&
1877
				!isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) {
1878
 
1879
				try {
1880
					if ( target[ type ] ) {
1881
						// Make sure that we don't accidentally re-trigger the onFOO events
1882
						old = target[ "on" + type ];
1883
 
1884
						if ( old ) {
1885
							target[ "on" + type ] = null;
1886
						}
1887
 
1888
						jQuery.event.triggered = true;
1889
						target[ type ]();
1890
					}
1891
 
1892
				// prevent IE from throwing an error for some elements with some event types, see #3533
1893
				} catch (e) {}
1894
 
1895
				if ( old ) {
1896
					target[ "on" + type ] = old;
1897
				}
1898
 
1899
				jQuery.event.triggered = false;
1900
			}
1901
		}
1902
	},
1903
 
1904
	handle: function( event ) {
1905
		var all, handlers, namespaces, namespace, events;
1906
 
1907
		event = arguments[0] = jQuery.event.fix( event || window.event );
1908
		event.currentTarget = this;
1909
 
1910
		// Namespaced event handlers
1911
		all = event.type.indexOf(".") < 0 && !event.exclusive;
1912
 
1913
		if ( !all ) {
1914
			namespaces = event.type.split(".");
1915
			event.type = namespaces.shift();
1916
			namespace = new RegExp("(^|\\.)" + namespaces.slice(0).sort().join("\\.(?:.*\\.)?") + "(\\.|$)");
1917
		}
1918
 
1919
		var events = jQuery.data(this, "events"), handlers = events[ event.type ];
1920
 
1921
		if ( events && handlers ) {
1922
			// Clone the handlers to prevent manipulation
1923
			handlers = handlers.slice(0);
1924
 
1925
			for ( var j = 0, l = handlers.length; j < l; j++ ) {
1926
				var handleObj = handlers[ j ];
1927
 
1928
				// Filter the functions by class
1929
				if ( all || namespace.test( handleObj.namespace ) ) {
1930
					// Pass in a reference to the handler function itself
1931
					// So that we can later remove it
1932
					event.handler = handleObj.handler;
1933
					event.data = handleObj.data;
1934
					event.handleObj = handleObj;
1935
 
1936
					var ret = handleObj.handler.apply( this, arguments );
1937
 
1938
					if ( ret !== undefined ) {
1939
						event.result = ret;
1940
						if ( ret === false ) {
1941
							event.preventDefault();
1942
							event.stopPropagation();
1943
						}
1944
					}
1945
 
1946
					if ( event.isImmediatePropagationStopped() ) {
1947
						break;
1948
					}
1949
				}
1950
			}
1951
		}
1952
 
1953
		return event.result;
1954
	},
1955
 
1956
	props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
1957
 
1958
	fix: function( event ) {
1959
		if ( event[ expando ] ) {
1960
			return event;
1961
		}
1962
 
1963
		// store a copy of the original event object
1964
		// and "clone" to set read-only properties
1965
		var originalEvent = event;
1966
		event = jQuery.Event( originalEvent );
1967
 
1968
		for ( var i = this.props.length, prop; i; ) {
1969
			prop = this.props[ --i ];
1970
			event[ prop ] = originalEvent[ prop ];
1971
		}
1972
 
1973
		// Fix target property, if necessary
1974
		if ( !event.target ) {
1975
			event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
1976
		}
1977
 
1978
		// check if target is a textnode (safari)
1979
		if ( event.target.nodeType === 3 ) {
1980
			event.target = event.target.parentNode;
1981
		}
1982
 
1983
		// Add relatedTarget, if necessary
1984
		if ( !event.relatedTarget && event.fromElement ) {
1985
			event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
1986
		}
1987
 
1988
		// Calculate pageX/Y if missing and clientX/Y available
1989
		if ( event.pageX == null && event.clientX != null ) {
1990
			var doc = document.documentElement, body = document.body;
1991
			event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
1992
			event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
1993
		}
1994
 
1995
		// Add which for key events
1996
		if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) ) {
1997
			event.which = event.charCode || event.keyCode;
1998
		}
1999
 
2000
		// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2001
		if ( !event.metaKey && event.ctrlKey ) {
2002
			event.metaKey = event.ctrlKey;
2003
		}
2004
 
2005
		// Add which for click: 1 === left; 2 === middle; 3 === right
2006
		// Note: button is not normalized, so don't use it
2007
		if ( !event.which && event.button !== undefined ) {
2008
			event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2009
		}
2010
 
2011
		return event;
2012
	},
2013
 
2014
	// Deprecated, use jQuery.guid instead
2015
	guid: 1E8,
2016
 
2017
	// Deprecated, use jQuery.proxy instead
2018
	proxy: jQuery.proxy,
2019
 
2020
	special: {
2021
		ready: {
2022
			// Make sure the ready event is setup
2023
			setup: jQuery.bindReady,
2024
			teardown: jQuery.noop
2025
		},
2026
 
2027
		live: {
2028
			add: function( handleObj ) {
2029
				jQuery.event.add( this, handleObj.origType, jQuery.extend({}, handleObj, {handler: liveHandler}) );
2030
			},
2031
 
2032
			remove: function( handleObj ) {
2033
				var remove = true,
2034
					type = handleObj.origType.replace(rnamespaces, "");
2035
 
2036
				jQuery.each( jQuery.data(this, "events").live || [], function() {
2037
					if ( type === this.origType.replace(rnamespaces, "") ) {
2038
						remove = false;
2039
						return false;
2040
					}
2041
				});
2042
 
2043
				if ( remove ) {
2044
					jQuery.event.remove( this, handleObj.origType, liveHandler );
2045
				}
2046
			}
2047
 
2048
		},
2049
 
2050
		beforeunload: {
2051
			setup: function( data, namespaces, eventHandle ) {
2052
				// We only want to do this special case on windows
2053
				if ( this.setInterval ) {
2054
					this.onbeforeunload = eventHandle;
2055
				}
2056
 
2057
				return false;
2058
			},
2059
			teardown: function( namespaces, eventHandle ) {
2060
				if ( this.onbeforeunload === eventHandle ) {
2061
					this.onbeforeunload = null;
2062
				}
2063
			}
2064
		}
2065
	}
2066
};
2067
 
2068
var removeEvent = document.removeEventListener ?
2069
	function( elem, type, handle ) {
2070
		elem.removeEventListener( type, handle, false );
2071
	} :
2072
	function( elem, type, handle ) {
2073
		elem.detachEvent( "on" + type, handle );
2074
	};
2075
 
2076
jQuery.Event = function( src ) {
2077
	// Allow instantiation without the 'new' keyword
2078
	if ( !this.preventDefault ) {
2079
		return new jQuery.Event( src );
2080
	}
2081
 
2082
	// Event object
2083
	if ( src && src.type ) {
2084
		this.originalEvent = src;
2085
		this.type = src.type;
2086
	// Event type
2087
	} else {
2088
		this.type = src;
2089
	}
2090
 
2091
	// timeStamp is buggy for some events on Firefox(#3843)
2092
	// So we won't rely on the native value
2093
	this.timeStamp = now();
2094
 
2095
	// Mark it as fixed
2096
	this[ expando ] = true;
2097
};
2098
 
2099
function returnFalse() {
2100
	return false;
2101
}
2102
function returnTrue() {
2103
	return true;
2104
}
2105
 
2106
// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
2107
// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
2108
jQuery.Event.prototype = {
2109
	preventDefault: function() {
2110
		this.isDefaultPrevented = returnTrue;
2111
 
2112
		var e = this.originalEvent;
2113
		if ( !e ) {
2114
			return;
2115
		}
2116
 
2117
		// if preventDefault exists run it on the original event
2118
		if ( e.preventDefault ) {
2119
			e.preventDefault();
2120
		}
2121
		// otherwise set the returnValue property of the original event to false (IE)
2122
		e.returnValue = false;
2123
	},
2124
	stopPropagation: function() {
2125
		this.isPropagationStopped = returnTrue;
2126
 
2127
		var e = this.originalEvent;
2128
		if ( !e ) {
2129
			return;
2130
		}
2131
		// if stopPropagation exists run it on the original event
2132
		if ( e.stopPropagation ) {
2133
			e.stopPropagation();
2134
		}
2135
		// otherwise set the cancelBubble property of the original event to true (IE)
2136
		e.cancelBubble = true;
2137
	},
2138
	stopImmediatePropagation: function() {
2139
		this.isImmediatePropagationStopped = returnTrue;
2140
		this.stopPropagation();
2141
	},
2142
	isDefaultPrevented: returnFalse,
2143
	isPropagationStopped: returnFalse,
2144
	isImmediatePropagationStopped: returnFalse
2145
};
2146
 
2147
// Checks if an event happened on an element within another element
2148
// Used in jQuery.event.special.mouseenter and mouseleave handlers
2149
var withinElement = function( event ) {
2150
	// Check if mouse(over|out) are still within the same parent element
2151
	var parent = event.relatedTarget;
2152
 
2153
	// Firefox sometimes assigns relatedTarget a XUL element
2154
	// which we cannot access the parentNode property of
2155
	try {
2156
		// Traverse up the tree
2157
		while ( parent && parent !== this ) {
2158
			parent = parent.parentNode;
2159
		}
2160
 
2161
		if ( parent !== this ) {
2162
			// set the correct event type
2163
			event.type = event.data;
2164
 
2165
			// handle event if we actually just moused on to a non sub-element
2166
			jQuery.event.handle.apply( this, arguments );
2167
		}
2168
 
2169
	// assuming we've left the element since we most likely mousedover a xul element
2170
	} catch(e) { }
2171
},
2172
 
2173
// In case of event delegation, we only need to rename the event.type,
2174
// liveHandler will take care of the rest.
2175
delegate = function( event ) {
2176
	event.type = event.data;
2177
	jQuery.event.handle.apply( this, arguments );
2178
};
2179
 
2180
// Create mouseenter and mouseleave events
2181
jQuery.each({
2182
	mouseenter: "mouseover",
2183
	mouseleave: "mouseout"
2184
}, function( orig, fix ) {
2185
	jQuery.event.special[ orig ] = {
2186
		setup: function( data ) {
2187
			jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
2188
		},
2189
		teardown: function( data ) {
2190
			jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
2191
		}
2192
	};
2193
});
2194
 
2195
// submit delegation
2196
if ( !jQuery.support.submitBubbles ) {
2197
 
2198
	jQuery.event.special.submit = {
2199
		setup: function( data, namespaces ) {
2200
			if ( this.nodeName.toLowerCase() !== "form" ) {
2201
				jQuery.event.add(this, "click.specialSubmit", function( e ) {
2202
					var elem = e.target, type = elem.type;
2203
 
2204
					if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
2205
						return trigger( "submit", this, arguments );
2206
					}
2207
				});
2208
 
2209
				jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
2210
					var elem = e.target, type = elem.type;
2211
 
2212
					if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
2213
						return trigger( "submit", this, arguments );
2214
					}
2215
				});
2216
 
2217
			} else {
2218
				return false;
2219
			}
2220
		},
2221
 
2222
		teardown: function( namespaces ) {
2223
			jQuery.event.remove( this, ".specialSubmit" );
2224
		}
2225
	};
2226
 
2227
}
2228
 
2229
// change delegation, happens here so we have bind.
2230
if ( !jQuery.support.changeBubbles ) {
2231
 
2232
	var formElems = /textarea|input|select/i,
2233
 
2234
	changeFilters,
2235
 
2236
	getVal = function( elem ) {
2237
		var type = elem.type, val = elem.value;
2238
 
2239
		if ( type === "radio" || type === "checkbox" ) {
2240
			val = elem.checked;
2241
 
2242
		} else if ( type === "select-multiple" ) {
2243
			val = elem.selectedIndex > -1 ?
2244
				jQuery.map( elem.options, function( elem ) {
2245
					return elem.selected;
2246
				}).join("-") :
2247
				"";
2248
 
2249
		} else if ( elem.nodeName.toLowerCase() === "select" ) {
2250
			val = elem.selectedIndex;
2251
		}
2252
 
2253
		return val;
2254
	},
2255
 
2256
	testChange = function testChange( e ) {
2257
		var elem = e.target, data, val;
2258
 
2259
		if ( !formElems.test( elem.nodeName ) || elem.readOnly ) {
2260
			return;
2261
		}
2262
 
2263
		data = jQuery.data( elem, "_change_data" );
2264
		val = getVal(elem);
2265
 
2266
		// the current data will be also retrieved by beforeactivate
2267
		if ( e.type !== "focusout" || elem.type !== "radio" ) {
2268
			jQuery.data( elem, "_change_data", val );
2269
		}
2270
 
2271
		if ( data === undefined || val === data ) {
2272
			return;
2273
		}
2274
 
2275
		if ( data != null || val ) {
2276
			e.type = "change";
2277
			return jQuery.event.trigger( e, arguments[1], elem );
2278
		}
2279
	};
2280
 
2281
	jQuery.event.special.change = {
2282
		filters: {
2283
			focusout: testChange,
2284
 
2285
			click: function( e ) {
2286
				var elem = e.target, type = elem.type;
2287
 
2288
				if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) {
2289
					return testChange.call( this, e );
2290
				}
2291
			},
2292
 
2293
			// Change has to be called before submit
2294
			// Keydown will be called before keypress, which is used in submit-event delegation
2295
			keydown: function( e ) {
2296
				var elem = e.target, type = elem.type;
2297
 
2298
				if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") ||
2299
					(e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
2300
					type === "select-multiple" ) {
2301
					return testChange.call( this, e );
2302
				}
2303
			},
2304
 
2305
			// Beforeactivate happens also before the previous element is blurred
2306
			// with this event you can't trigger a change event, but you can store
2307
			// information/focus[in] is not needed anymore
2308
			beforeactivate: function( e ) {
2309
				var elem = e.target;
2310
				jQuery.data( elem, "_change_data", getVal(elem) );
2311
			}
2312
		},
2313
 
2314
		setup: function( data, namespaces ) {
2315
			if ( this.type === "file" ) {
2316
				return false;
2317
			}
2318
 
2319
			for ( var type in changeFilters ) {
2320
				jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
2321
			}
2322
 
2323
			return formElems.test( this.nodeName );
2324
		},
2325
 
2326
		teardown: function( namespaces ) {
2327
			jQuery.event.remove( this, ".specialChange" );
2328
 
2329
			return formElems.test( this.nodeName );
2330
		}
2331
	};
2332
 
2333
	changeFilters = jQuery.event.special.change.filters;
2334
}
2335
 
2336
function trigger( type, elem, args ) {
2337
	args[0].type = type;
2338
	return jQuery.event.handle.apply( elem, args );
2339
}
2340
 
2341
// Create "bubbling" focus and blur events
2342
if ( document.addEventListener ) {
2343
	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
2344
		jQuery.event.special[ fix ] = {
2345
			setup: function() {
2346
				this.addEventListener( orig, handler, true );
2347
			},
2348
			teardown: function() {
2349
				this.removeEventListener( orig, handler, true );
2350
			}
2351
		};
2352
 
2353
		function handler( e ) {
2354
			e = jQuery.event.fix( e );
2355
			e.type = fix;
2356
			return jQuery.event.handle.call( this, e );
2357
		}
2358
	});
2359
}
2360
 
2361
jQuery.each(["bind", "one"], function( i, name ) {
2362
	jQuery.fn[ name ] = function( type, data, fn ) {
2363
		// Handle object literals
2364
		if ( typeof type === "object" ) {
2365
			for ( var key in type ) {
2366
				this[ name ](key, data, type[key], fn);
2367
			}
2368
			return this;
2369
		}
2370
 
2371
		if ( jQuery.isFunction( data ) ) {
2372
			fn = data;
2373
			data = undefined;
2374
		}
2375
 
2376
		var handler = name === "one" ? jQuery.proxy( fn, function( event ) {
2377
			jQuery( this ).unbind( event, handler );
2378
			return fn.apply( this, arguments );
2379
		}) : fn;
2380
 
2381
		if ( type === "unload" && name !== "one" ) {
2382
			this.one( type, data, fn );
2383
 
2384
		} else {
2385
			for ( var i = 0, l = this.length; i < l; i++ ) {
2386
				jQuery.event.add( this[i], type, handler, data );
2387
			}
2388
		}
2389
 
2390
		return this;
2391
	};
2392
});
2393
 
2394
jQuery.fn.extend({
2395
	unbind: function( type, fn ) {
2396
		// Handle object literals
2397
		if ( typeof type === "object" && !type.preventDefault ) {
2398
			for ( var key in type ) {
2399
				this.unbind(key, type[key]);
2400
			}
2401
 
2402
		} else {
2403
			for ( var i = 0, l = this.length; i < l; i++ ) {
2404
				jQuery.event.remove( this[i], type, fn );
2405
			}
2406
		}
2407
 
2408
		return this;
2409
	},
2410
 
2411
	delegate: function( selector, types, data, fn ) {
2412
		return this.live( types, data, fn, selector );
2413
	},
2414
 
2415
	undelegate: function( selector, types, fn ) {
2416
		if ( arguments.length === 0 ) {
2417
				return this.unbind( "live" );
2418
 
2419
		} else {
2420
			return this.die( types, null, fn, selector );
2421
		}
2422
	},
2423
 
2424
	trigger: function( type, data ) {
2425
		return this.each(function() {
2426
			jQuery.event.trigger( type, data, this );
2427
		});
2428
	},
2429
 
2430
	triggerHandler: function( type, data ) {
2431
		if ( this[0] ) {
2432
			var event = jQuery.Event( type );
2433
			event.preventDefault();
2434
			event.stopPropagation();
2435
			jQuery.event.trigger( event, data, this[0] );
2436
			return event.result;
2437
		}
2438
	},
2439
 
2440
	toggle: function( fn ) {
2441
		// Save reference to arguments for access in closure
2442
		var args = arguments, i = 1;
2443
 
2444
		// link all the functions, so any of them can unbind this click handler
2445
		while ( i < args.length ) {
2446
			jQuery.proxy( fn, args[ i++ ] );
2447
		}
2448
 
2449
		return this.click( jQuery.proxy( fn, function( event ) {
2450
			// Figure out which function to execute
2451
			var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
2452
			jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
2453
 
2454
			// Make sure that clicks stop
2455
			event.preventDefault();
2456
 
2457
			// and execute the function
2458
			return args[ lastToggle ].apply( this, arguments ) || false;
2459
		}));
2460
	},
2461
 
2462
	hover: function( fnOver, fnOut ) {
2463
		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
2464
	}
2465
});
2466
 
2467
var liveMap = {
2468
	focus: "focusin",
2469
	blur: "focusout",
2470
	mouseenter: "mouseover",
2471
	mouseleave: "mouseout"
2472
};
2473
 
2474
jQuery.each(["live", "die"], function( i, name ) {
2475
	jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
2476
		var type, i = 0, match, namespaces, preType,
2477
			selector = origSelector || this.selector,
2478
			context = origSelector ? this : jQuery( this.context );
2479
 
2480
		if ( jQuery.isFunction( data ) ) {
2481
			fn = data;
2482
			data = undefined;
2483
		}
2484
 
2485
		types = (types || "").split(" ");
2486
 
2487
		while ( (type = types[ i++ ]) != null ) {
2488
			match = rnamespaces.exec( type );
2489
			namespaces = "";
2490
 
2491
			if ( match )  {
2492
				namespaces = match[0];
2493
				type = type.replace( rnamespaces, "" );
2494
			}
2495
 
2496
			if ( type === "hover" ) {
2497
				types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
2498
				continue;
2499
			}
2500
 
2501
			preType = type;
2502
 
2503
			if ( type === "focus" || type === "blur" ) {
2504
				types.push( liveMap[ type ] + namespaces );
2505
				type = type + namespaces;
2506
 
2507
			} else {
2508
				type = (liveMap[ type ] || type) + namespaces;
2509
			}
2510
 
2511
			if ( name === "live" ) {
2512
				// bind live handler
2513
				context.each(function(){
2514
					jQuery.event.add( this, liveConvert( type, selector ),
2515
						{ data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
2516
				});
2517
 
2518
			} else {
2519
				// unbind live handler
2520
				context.unbind( liveConvert( type, selector ), fn );
2521
			}
2522
		}
2523
 
2524
		return this;
2525
	}
2526
});
2527
 
2528
function liveHandler( event ) {
2529
	var stop, elems = [], selectors = [], args = arguments,
2530
		related, match, handleObj, elem, j, i, l, data,
2531
		events = jQuery.data( this, "events" );
2532
 
2533
	// Make sure we avoid non-left-click bubbling in Firefox (#3861)
2534
	if ( event.liveFired === this || !events || !events.live || event.button && event.type === "click" ) {
2535
		return;
2536
	}
2537
 
2538
	event.liveFired = this;
2539
 
2540
	var live = events.live.slice(0);
2541
 
2542
	for ( j = 0; j < live.length; j++ ) {
2543
		handleObj = live[j];
2544
 
2545
		if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
2546
			selectors.push( handleObj.selector );
2547
 
2548
		} else {
2549
			live.splice( j--, 1 );
2550
		}
2551
	}
2552
 
2553
	match = jQuery( event.target ).closest( selectors, event.currentTarget );
2554
 
2555
	for ( i = 0, l = match.length; i < l; i++ ) {
2556
		for ( j = 0; j < live.length; j++ ) {
2557
			handleObj = live[j];
2558
 
2559
			if ( match[i].selector === handleObj.selector ) {
2560
				elem = match[i].elem;
2561
				related = null;
2562
 
2563
				// Those two events require additional checking
2564
				if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
2565
					related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
2566
				}
2567
 
2568
				if ( !related || related !== elem ) {
2569
					elems.push({ elem: elem, handleObj: handleObj });
2570
				}
2571
			}
2572
		}
2573
	}
2574
 
2575
	for ( i = 0, l = elems.length; i < l; i++ ) {
2576
		match = elems[i];
2577
		event.currentTarget = match.elem;
2578
		event.data = match.handleObj.data;
2579
		event.handleObj = match.handleObj;
2580
 
2581
		if ( match.handleObj.origHandler.apply( match.elem, args ) === false ) {
2582
			stop = false;
2583
			break;
2584
		}
2585
	}
2586
 
2587
	return stop;
2588
}
2589
 
2590
function liveConvert( type, selector ) {
2591
	return "live." + (type && type !== "*" ? type + "." : "") + selector.replace(/\./g, "`").replace(/ /g, "&");
2592
}
2593
 
2594
jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
2595
	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
2596
	"change select submit keydown keypress keyup error").split(" "), function( i, name ) {
2597
 
2598
	// Handle event binding
2599
	jQuery.fn[ name ] = function( fn ) {
2600
		return fn ? this.bind( name, fn ) : this.trigger( name );
2601
	};
2602
 
2603
	if ( jQuery.attrFn ) {
2604
		jQuery.attrFn[ name ] = true;
2605
	}
2606
});
2607
 
2608
// Prevent memory leaks in IE
2609
// Window isn't included so as not to unbind existing unload events
2610
// More info:
2611
//  - http://isaacschlueter.com/2006/10/msie-memory-leaks/
2612
if ( window.attachEvent && !window.addEventListener ) {
2613
	window.attachEvent("onunload", function() {
2614
		for ( var id in jQuery.cache ) {
2615
			if ( jQuery.cache[ id ].handle ) {
2616
				// Try/Catch is to handle iframes being unloaded, see #4280
2617
				try {
2618
					jQuery.event.remove( jQuery.cache[ id ].handle.elem );
2619
				} catch(e) {}
2620
			}
2621
		}
2622
	});
2623
}
2624
/*!
2625
 * Sizzle CSS Selector Engine - v1.0
2626
 *  Copyright 2009, The Dojo Foundation
2627
 *  Released under the MIT, BSD, and GPL Licenses.
2628
 *  More information: http://sizzlejs.com/
2629
 */
2630
(function(){
2631
 
2632
var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
2633
	done = 0,
2634
	toString = Object.prototype.toString,
2635
	hasDuplicate = false,
2636
	baseHasDuplicate = true;
2637
 
2638
// Here we check if the JavaScript engine is using some sort of
2639
// optimization where it does not always call our comparision
2640
// function. If that is the case, discard the hasDuplicate value.
2641
//   Thus far that includes Google Chrome.
2642
[0, 0].sort(function(){
2643
	baseHasDuplicate = false;
2644
	return 0;
2645
});
2646
 
2647
var Sizzle = function(selector, context, results, seed) {
2648
	results = results || [];
2649
	var origContext = context = context || document;
2650
 
2651
	if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
2652
		return [];
2653
	}
2654
 
2655
	if ( !selector || typeof selector !== "string" ) {
2656
		return results;
2657
	}
2658
 
2659
	var parts = [], m, set, checkSet, extra, prune = true, contextXML = isXML(context),
2660
		soFar = selector;
2661
 
2662
	// Reset the position of the chunker regexp (start from head)
2663
	while ( (chunker.exec(""), m = chunker.exec(soFar)) !== null ) {
2664
		soFar = m[3];
2665
 
2666
		parts.push( m[1] );
2667
 
2668
		if ( m[2] ) {
2669
			extra = m[3];
2670
			break;
2671
		}
2672
	}
2673
 
2674
	if ( parts.length > 1 && origPOS.exec( selector ) ) {
2675
		if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
2676
			set = posProcess( parts[0] + parts[1], context );
2677
		} else {
2678
			set = Expr.relative[ parts[0] ] ?
2679
				[ context ] :
2680
				Sizzle( parts.shift(), context );
2681
 
2682
			while ( parts.length ) {
2683
				selector = parts.shift();
2684
 
2685
				if ( Expr.relative[ selector ] ) {
2686
					selector += parts.shift();
2687
				}
2688
 
2689
				set = posProcess( selector, set );
2690
			}
2691
		}
2692
	} else {
2693
		// Take a shortcut and set the context if the root selector is an ID
2694
		// (but not if it'll be faster if the inner selector is an ID)
2695
		if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
2696
				Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
2697
			var ret = Sizzle.find( parts.shift(), context, contextXML );
2698
			context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0];
2699
		}
2700
 
2701
		if ( context ) {
2702
			var ret = seed ?
2703
				{ expr: parts.pop(), set: makeArray(seed) } :
2704
				Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
2705
			set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set;
2706
 
2707
			if ( parts.length > 0 ) {
2708
				checkSet = makeArray(set);
2709
			} else {
2710
				prune = false;
2711
			}
2712
 
2713
			while ( parts.length ) {
2714
				var cur = parts.pop(), pop = cur;
2715
 
2716
				if ( !Expr.relative[ cur ] ) {
2717
					cur = "";
2718
				} else {
2719
					pop = parts.pop();
2720
				}
2721
 
2722
				if ( pop == null ) {
2723
					pop = context;
2724
				}
2725
 
2726
				Expr.relative[ cur ]( checkSet, pop, contextXML );
2727
			}
2728
		} else {
2729
			checkSet = parts = [];
2730
		}
2731
	}
2732
 
2733
	if ( !checkSet ) {
2734
		checkSet = set;
2735
	}
2736
 
2737
	if ( !checkSet ) {
2738
		Sizzle.error( cur || selector );
2739
	}
2740
 
2741
	if ( toString.call(checkSet) === "[object Array]" ) {
2742
		if ( !prune ) {
2743
			results.push.apply( results, checkSet );
2744
		} else if ( context && context.nodeType === 1 ) {
2745
			for ( var i = 0; checkSet[i] != null; i++ ) {
2746
				if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
2747
					results.push( set[i] );
2748
				}
2749
			}
2750
		} else {
2751
			for ( var i = 0; checkSet[i] != null; i++ ) {
2752
				if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
2753
					results.push( set[i] );
2754
				}
2755
			}
2756
		}
2757
	} else {
2758
		makeArray( checkSet, results );
2759
	}
2760
 
2761
	if ( extra ) {
2762
		Sizzle( extra, origContext, results, seed );
2763
		Sizzle.uniqueSort( results );
2764
	}
2765
 
2766
	return results;
2767
};
2768
 
2769
Sizzle.uniqueSort = function(results){
2770
	if ( sortOrder ) {
2771
		hasDuplicate = baseHasDuplicate;
2772
		results.sort(sortOrder);
2773
 
2774
		if ( hasDuplicate ) {
2775
			for ( var i = 1; i < results.length; i++ ) {
2776
				if ( results[i] === results[i-1] ) {
2777
					results.splice(i--, 1);
2778
				}
2779
			}
2780
		}
2781
	}
2782
 
2783
	return results;
2784
};
2785
 
2786
Sizzle.matches = function(expr, set){
2787
	return Sizzle(expr, null, null, set);
2788
};
2789
 
2790
Sizzle.find = function(expr, context, isXML){
2791
	var set, match;
2792
 
2793
	if ( !expr ) {
2794
		return [];
2795
	}
2796
 
2797
	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
2798
		var type = Expr.order[i], match;
2799
 
2800
		if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
2801
			var left = match[1];
2802
			match.splice(1,1);
2803
 
2804
			if ( left.substr( left.length - 1 ) !== "\\" ) {
2805
				match[1] = (match[1] || "").replace(/\\/g, "");
2806
				set = Expr.find[ type ]( match, context, isXML );
2807
				if ( set != null ) {
2808
					expr = expr.replace( Expr.match[ type ], "" );
2809
					break;
2810
				}
2811
			}
2812
		}
2813
	}
2814
 
2815
	if ( !set ) {
2816
		set = context.getElementsByTagName("*");
2817
	}
2818
 
2819
	return {set: set, expr: expr};
2820
};
2821
 
2822
Sizzle.filter = function(expr, set, inplace, not){
2823
	var old = expr, result = [], curLoop = set, match, anyFound,
2824
		isXMLFilter = set && set[0] && isXML(set[0]);
2825
 
2826
	while ( expr && set.length ) {
2827
		for ( var type in Expr.filter ) {
2828
			if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
2829
				var filter = Expr.filter[ type ], found, item, left = match[1];
2830
				anyFound = false;
2831
 
2832
				match.splice(1,1);
2833
 
2834
				if ( left.substr( left.length - 1 ) === "\\" ) {
2835
					continue;
2836
				}
2837
 
2838
				if ( curLoop === result ) {
2839
					result = [];
2840
				}
2841
 
2842
				if ( Expr.preFilter[ type ] ) {
2843
					match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
2844
 
2845
					if ( !match ) {
2846
						anyFound = found = true;
2847
					} else if ( match === true ) {
2848
						continue;
2849
					}
2850
				}
2851
 
2852
				if ( match ) {
2853
					for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
2854
						if ( item ) {
2855
							found = filter( item, match, i, curLoop );
2856
							var pass = not ^ !!found;
2857
 
2858
							if ( inplace && found != null ) {
2859
								if ( pass ) {
2860
									anyFound = true;
2861
								} else {
2862
									curLoop[i] = false;
2863
								}
2864
							} else if ( pass ) {
2865
								result.push( item );
2866
								anyFound = true;
2867
							}
2868
						}
2869
					}
2870
				}
2871
 
2872
				if ( found !== undefined ) {
2873
					if ( !inplace ) {
2874
						curLoop = result;
2875
					}
2876
 
2877
					expr = expr.replace( Expr.match[ type ], "" );
2878
 
2879
					if ( !anyFound ) {
2880
						return [];
2881
					}
2882
 
2883
					break;
2884
				}
2885
			}
2886
		}
2887
 
2888
		// Improper expression
2889
		if ( expr === old ) {
2890
			if ( anyFound == null ) {
2891
				Sizzle.error( expr );
2892
			} else {
2893
				break;
2894
			}
2895
		}
2896
 
2897
		old = expr;
2898
	}
2899
 
2900
	return curLoop;
2901
};
2902
 
2903
Sizzle.error = function( msg ) {
2904
	throw "Syntax error, unrecognized expression: " + msg;
2905
};
2906
 
2907
var Expr = Sizzle.selectors = {
2908
	order: [ "ID", "NAME", "TAG" ],
2909
	match: {
2910
		ID: /#((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
2911
		CLASS: /\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
2912
		NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/,
2913
		ATTR: /\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
2914
		TAG: /^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/,
2915
		CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
2916
		POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
2917
		PSEUDO: /:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
2918
	},
2919
	leftMatch: {},
2920
	attrMap: {
2921
		"class": "className",
2922
		"for": "htmlFor"
2923
	},
2924
	attrHandle: {
2925
		href: function(elem){
2926
			return elem.getAttribute("href");
2927
		}
2928
	},
2929
	relative: {
2930
		"+": function(checkSet, part){
2931
			var isPartStr = typeof part === "string",
2932
				isTag = isPartStr && !/\W/.test(part),
2933
				isPartStrNotTag = isPartStr && !isTag;
2934
 
2935
			if ( isTag ) {
2936
				part = part.toLowerCase();
2937
			}
2938
 
2939
			for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
2940
				if ( (elem = checkSet[i]) ) {
2941
					while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
2942
 
2943
					checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
2944
						elem || false :
2945
						elem === part;
2946
				}
2947
			}
2948
 
2949
			if ( isPartStrNotTag ) {
2950
				Sizzle.filter( part, checkSet, true );
2951
			}
2952
		},
2953
		">": function(checkSet, part){
2954
			var isPartStr = typeof part === "string";
2955
 
2956
			if ( isPartStr && !/\W/.test(part) ) {
2957
				part = part.toLowerCase();
2958
 
2959
				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2960
					var elem = checkSet[i];
2961
					if ( elem ) {
2962
						var parent = elem.parentNode;
2963
						checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
2964
					}
2965
				}
2966
			} else {
2967
				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2968
					var elem = checkSet[i];
2969
					if ( elem ) {
2970
						checkSet[i] = isPartStr ?
2971
							elem.parentNode :
2972
							elem.parentNode === part;
2973
					}
2974
				}
2975
 
2976
				if ( isPartStr ) {
2977
					Sizzle.filter( part, checkSet, true );
2978
				}
2979
			}
2980
		},
2981
		"": function(checkSet, part, isXML){
2982
			var doneName = done++, checkFn = dirCheck;
2983
 
2984
			if ( typeof part === "string" && !/\W/.test(part) ) {
2985
				var nodeCheck = part = part.toLowerCase();
2986
				checkFn = dirNodeCheck;
2987
			}
2988
 
2989
			checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
2990
		},
2991
		"~": function(checkSet, part, isXML){
2992
			var doneName = done++, checkFn = dirCheck;
2993
 
2994
			if ( typeof part === "string" && !/\W/.test(part) ) {
2995
				var nodeCheck = part = part.toLowerCase();
2996
				checkFn = dirNodeCheck;
2997
			}
2998
 
2999
			checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
3000
		}
3001
	},
3002
	find: {
3003
		ID: function(match, context, isXML){
3004
			if ( typeof context.getElementById !== "undefined" && !isXML ) {
3005
				var m = context.getElementById(match[1]);
3006
				return m ? [m] : [];
3007
			}
3008
		},
3009
		NAME: function(match, context){
3010
			if ( typeof context.getElementsByName !== "undefined" ) {
3011
				var ret = [], results = context.getElementsByName(match[1]);
3012
 
3013
				for ( var i = 0, l = results.length; i < l; i++ ) {
3014
					if ( results[i].getAttribute("name") === match[1] ) {
3015
						ret.push( results[i] );
3016
					}
3017
				}
3018
 
3019
				return ret.length === 0 ? null : ret;
3020
			}
3021
		},
3022
		TAG: function(match, context){
3023
			return context.getElementsByTagName(match[1]);
3024
		}
3025
	},
3026
	preFilter: {
3027
		CLASS: function(match, curLoop, inplace, result, not, isXML){
3028
			match = " " + match[1].replace(/\\/g, "") + " ";
3029
 
3030
			if ( isXML ) {
3031
				return match;
3032
			}
3033
 
3034
			for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
3035
				if ( elem ) {
3036
					if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n]/g, " ").indexOf(match) >= 0) ) {
3037
						if ( !inplace ) {
3038
							result.push( elem );
3039
						}
3040
					} else if ( inplace ) {
3041
						curLoop[i] = false;
3042
					}
3043
				}
3044
			}
3045
 
3046
			return false;
3047
		},
3048
		ID: function(match){
3049
			return match[1].replace(/\\/g, "");
3050
		},
3051
		TAG: function(match, curLoop){
3052
			return match[1].toLowerCase();
3053
		},
3054
		CHILD: function(match){
3055
			if ( match[1] === "nth" ) {
3056
				// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
3057
				var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
3058
					match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
3059
					!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
3060
 
3061
				// calculate the numbers (first)n+(last) including if they are negative
3062
				match[2] = (test[1] + (test[2] || 1)) - 0;
3063
				match[3] = test[3] - 0;
3064
			}
3065
 
3066
			// TODO: Move to normal caching system
3067
			match[0] = done++;
3068
 
3069
			return match;
3070
		},
3071
		ATTR: function(match, curLoop, inplace, result, not, isXML){
3072
			var name = match[1].replace(/\\/g, "");
3073
 
3074
			if ( !isXML && Expr.attrMap[name] ) {
3075
				match[1] = Expr.attrMap[name];
3076
			}
3077
 
3078
			if ( match[2] === "~=" ) {
3079
				match[4] = " " + match[4] + " ";
3080
			}
3081
 
3082
			return match;
3083
		},
3084
		PSEUDO: function(match, curLoop, inplace, result, not){
3085
			if ( match[1] === "not" ) {
3086
				// If we're dealing with a complex expression, or a simple one
3087
				if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
3088
					match[3] = Sizzle(match[3], null, null, curLoop);
3089
				} else {
3090
					var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
3091
					if ( !inplace ) {
3092
						result.push.apply( result, ret );
3093
					}
3094
					return false;
3095
				}
3096
			} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
3097
				return true;
3098
			}
3099
 
3100
			return match;
3101
		},
3102
		POS: function(match){
3103
			match.unshift( true );
3104
			return match;
3105
		}
3106
	},
3107
	filters: {
3108
		enabled: function(elem){
3109
			return elem.disabled === false && elem.type !== "hidden";
3110
		},
3111
		disabled: function(elem){
3112
			return elem.disabled === true;
3113
		},
3114
		checked: function(elem){
3115
			return elem.checked === true;
3116
		},
3117
		selected: function(elem){
3118
			// Accessing this property makes selected-by-default
3119
			// options in Safari work properly
3120
			elem.parentNode.selectedIndex;
3121
			return elem.selected === true;
3122
		},
3123
		parent: function(elem){
3124
			return !!elem.firstChild;
3125
		},
3126
		empty: function(elem){
3127
			return !elem.firstChild;
3128
		},
3129
		has: function(elem, i, match){
3130
			return !!Sizzle( match[3], elem ).length;
3131
		},
3132
		header: function(elem){
3133
			return /h\d/i.test( elem.nodeName );
3134
		},
3135
		text: function(elem){
3136
			return "text" === elem.type;
3137
		},
3138
		radio: function(elem){
3139
			return "radio" === elem.type;
3140
		},
3141
		checkbox: function(elem){
3142
			return "checkbox" === elem.type;
3143
		},
3144
		file: function(elem){
3145
			return "file" === elem.type;
3146
		},
3147
		password: function(elem){
3148
			return "password" === elem.type;
3149
		},
3150
		submit: function(elem){
3151
			return "submit" === elem.type;
3152
		},
3153
		image: function(elem){
3154
			return "image" === elem.type;
3155
		},
3156
		reset: function(elem){
3157
			return "reset" === elem.type;
3158
		},
3159
		button: function(elem){
3160
			return "button" === elem.type || elem.nodeName.toLowerCase() === "button";
3161
		},
3162
		input: function(elem){
3163
			return /input|select|textarea|button/i.test(elem.nodeName);
3164
		}
3165
	},
3166
	setFilters: {
3167
		first: function(elem, i){
3168
			return i === 0;
3169
		},
3170
		last: function(elem, i, match, array){
3171
			return i === array.length - 1;
3172
		},
3173
		even: function(elem, i){
3174
			return i % 2 === 0;
3175
		},
3176
		odd: function(elem, i){
3177
			return i % 2 === 1;
3178
		},
3179
		lt: function(elem, i, match){
3180
			return i < match[3] - 0;
3181
		},
3182
		gt: function(elem, i, match){
3183
			return i > match[3] - 0;
3184
		},
3185
		nth: function(elem, i, match){
3186
			return match[3] - 0 === i;
3187
		},
3188
		eq: function(elem, i, match){
3189
			return match[3] - 0 === i;
3190
		}
3191
	},
3192
	filter: {
3193
		PSEUDO: function(elem, match, i, array){
3194
			var name = match[1], filter = Expr.filters[ name ];
3195
 
3196
			if ( filter ) {
3197
				return filter( elem, i, match, array );
3198
			} else if ( name === "contains" ) {
3199
				return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0;
3200
			} else if ( name === "not" ) {
3201
				var not = match[3];
3202
 
3203
				for ( var i = 0, l = not.length; i < l; i++ ) {
3204
					if ( not[i] === elem ) {
3205
						return false;
3206
					}
3207
				}
3208
 
3209
				return true;
3210
			} else {
3211
				Sizzle.error( "Syntax error, unrecognized expression: " + name );
3212
			}
3213
		},
3214
		CHILD: function(elem, match){
3215
			var type = match[1], node = elem;
3216
			switch (type) {
3217
				case 'only':
3218
				case 'first':
3219
					while ( (node = node.previousSibling) )	 {
3220
						if ( node.nodeType === 1 ) {
3221
							return false;
3222
						}
3223
					}
3224
					if ( type === "first" ) {
3225
						return true;
3226
					}
3227
					node = elem;
3228
				case 'last':
3229
					while ( (node = node.nextSibling) )	 {
3230
						if ( node.nodeType === 1 ) {
3231
							return false;
3232
						}
3233
					}
3234
					return true;
3235
				case 'nth':
3236
					var first = match[2], last = match[3];
3237
 
3238
					if ( first === 1 && last === 0 ) {
3239
						return true;
3240
					}
3241
 
3242
					var doneName = match[0],
3243
						parent = elem.parentNode;
3244
 
3245
					if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
3246
						var count = 0;
3247
						for ( node = parent.firstChild; node; node = node.nextSibling ) {
3248
							if ( node.nodeType === 1 ) {
3249
								node.nodeIndex = ++count;
3250
							}
3251
						}
3252
						parent.sizcache = doneName;
3253
					}
3254
 
3255
					var diff = elem.nodeIndex - last;
3256
					if ( first === 0 ) {
3257
						return diff === 0;
3258
					} else {
3259
						return ( diff % first === 0 && diff / first >= 0 );
3260
					}
3261
			}
3262
		},
3263
		ID: function(elem, match){
3264
			return elem.nodeType === 1 && elem.getAttribute("id") === match;
3265
		},
3266
		TAG: function(elem, match){
3267
			return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
3268
		},
3269
		CLASS: function(elem, match){
3270
			return (" " + (elem.className || elem.getAttribute("class")) + " ")
3271
				.indexOf( match ) > -1;
3272
		},
3273
		ATTR: function(elem, match){
3274
			var name = match[1],
3275
				result = Expr.attrHandle[ name ] ?
3276
					Expr.attrHandle[ name ]( elem ) :
3277
					elem[ name ] != null ?
3278
						elem[ name ] :
3279
						elem.getAttribute( name ),
3280
				value = result + "",
3281
				type = match[2],
3282
				check = match[4];
3283
 
3284
			return result == null ?
3285
				type === "!=" :
3286
				type === "=" ?
3287
				value === check :
3288
				type === "*=" ?
3289
				value.indexOf(check) >= 0 :
3290
				type === "~=" ?
3291
				(" " + value + " ").indexOf(check) >= 0 :
3292
				!check ?
3293
				value && result !== false :
3294
				type === "!=" ?
3295
				value !== check :
3296
				type === "^=" ?
3297
				value.indexOf(check) === 0 :
3298
				type === "$=" ?
3299
				value.substr(value.length - check.length) === check :
3300
				type === "|=" ?
3301
				value === check || value.substr(0, check.length + 1) === check + "-" :
3302
				false;
3303
		},
3304
		POS: function(elem, match, i, array){
3305
			var name = match[2], filter = Expr.setFilters[ name ];
3306
 
3307
			if ( filter ) {
3308
				return filter( elem, i, match, array );
3309
			}
3310
		}
3311
	}
3312
};
3313
 
3314
var origPOS = Expr.match.POS;
3315
 
3316
for ( var type in Expr.match ) {
3317
	Expr.match[ type ] = new RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
3318
	Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, function(all, num){
3319
		return "\\" + (num - 0 + 1);
3320
	}));
3321
}
3322
 
3323
var makeArray = function(array, results) {
3324
	array = Array.prototype.slice.call( array, 0 );
3325
 
3326
	if ( results ) {
3327
		results.push.apply( results, array );
3328
		return results;
3329
	}
3330
 
3331
	return array;
3332
};
3333
 
3334
// Perform a simple check to determine if the browser is capable of
3335
// converting a NodeList to an array using builtin methods.
3336
// Also verifies that the returned array holds DOM nodes
3337
// (which is not the case in the Blackberry browser)
3338
try {
3339
	Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
3340
 
3341
// Provide a fallback method if it does not work
3342
} catch(e){
3343
	makeArray = function(array, results) {
3344
		var ret = results || [];
3345
 
3346
		if ( toString.call(array) === "[object Array]" ) {
3347
			Array.prototype.push.apply( ret, array );
3348
		} else {
3349
			if ( typeof array.length === "number" ) {
3350
				for ( var i = 0, l = array.length; i < l; i++ ) {
3351
					ret.push( array[i] );
3352
				}
3353
			} else {
3354
				for ( var i = 0; array[i]; i++ ) {
3355
					ret.push( array[i] );
3356
				}
3357
			}
3358
		}
3359
 
3360
		return ret;
3361
	};
3362
}
3363
 
3364
var sortOrder;
3365
 
3366
if ( document.documentElement.compareDocumentPosition ) {
3367
	sortOrder = function( a, b ) {
3368
		if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
3369
			if ( a == b ) {
3370
				hasDuplicate = true;
3371
			}
3372
			return a.compareDocumentPosition ? -1 : 1;
3373
		}
3374
 
3375
		var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
3376
		if ( ret === 0 ) {
3377
			hasDuplicate = true;
3378
		}
3379
		return ret;
3380
	};
3381
} else if ( "sourceIndex" in document.documentElement ) {
3382
	sortOrder = function( a, b ) {
3383
		if ( !a.sourceIndex || !b.sourceIndex ) {
3384
			if ( a == b ) {
3385
				hasDuplicate = true;
3386
			}
3387
			return a.sourceIndex ? -1 : 1;
3388
		}
3389
 
3390
		var ret = a.sourceIndex - b.sourceIndex;
3391
		if ( ret === 0 ) {
3392
			hasDuplicate = true;
3393
		}
3394
		return ret;
3395
	};
3396
} else if ( document.createRange ) {
3397
	sortOrder = function( a, b ) {
3398
		if ( !a.ownerDocument || !b.ownerDocument ) {
3399
			if ( a == b ) {
3400
				hasDuplicate = true;
3401
			}
3402
			return a.ownerDocument ? -1 : 1;
3403
		}
3404
 
3405
		var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
3406
		aRange.setStart(a, 0);
3407
		aRange.setEnd(a, 0);
3408
		bRange.setStart(b, 0);
3409
		bRange.setEnd(b, 0);
3410
		var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
3411
		if ( ret === 0 ) {
3412
			hasDuplicate = true;
3413
		}
3414
		return ret;
3415
	};
3416
}
3417
 
3418
// Utility function for retreiving the text value of an array of DOM nodes
3419
function getText( elems ) {
3420
	var ret = "", elem;
3421
 
3422
	for ( var i = 0; elems[i]; i++ ) {
3423
		elem = elems[i];
3424
 
3425
		// Get the text from text nodes and CDATA nodes
3426
		if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
3427
			ret += elem.nodeValue;
3428
 
3429
		// Traverse everything else, except comment nodes
3430
		} else if ( elem.nodeType !== 8 ) {
3431
			ret += getText( elem.childNodes );
3432
		}
3433
	}
3434
 
3435
	return ret;
3436
}
3437
 
3438
// Check to see if the browser returns elements by name when
3439
// querying by getElementById (and provide a workaround)
3440
(function(){
3441
	// We're going to inject a fake input element with a specified name
3442
	var form = document.createElement("div"),
3443
		id = "script" + (new Date).getTime();
3444
	form.innerHTML = "<a name='" + id + "'/>";
3445
 
3446
	// Inject it into the root element, check its status, and remove it quickly
3447
	var root = document.documentElement;
3448
	root.insertBefore( form, root.firstChild );
3449
 
3450
	// The workaround has to do additional checks after a getElementById
3451
	// Which slows things down for other browsers (hence the branching)
3452
	if ( document.getElementById( id ) ) {
3453
		Expr.find.ID = function(match, context, isXML){
3454
			if ( typeof context.getElementById !== "undefined" && !isXML ) {
3455
				var m = context.getElementById(match[1]);
3456
				return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
3457
			}
3458
		};
3459
 
3460
		Expr.filter.ID = function(elem, match){
3461
			var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
3462
			return elem.nodeType === 1 && node && node.nodeValue === match;
3463
		};
3464
	}
3465
 
3466
	root.removeChild( form );
3467
	root = form = null; // release memory in IE
3468
})();
3469
 
3470
(function(){
3471
	// Check to see if the browser returns only elements
3472
	// when doing getElementsByTagName("*")
3473
 
3474
	// Create a fake element
3475
	var div = document.createElement("div");
3476
	div.appendChild( document.createComment("") );
3477
 
3478
	// Make sure no comments are found
3479
	if ( div.getElementsByTagName("*").length > 0 ) {
3480
		Expr.find.TAG = function(match, context){
3481
			var results = context.getElementsByTagName(match[1]);
3482
 
3483
			// Filter out possible comments
3484
			if ( match[1] === "*" ) {
3485
				var tmp = [];
3486
 
3487
				for ( var i = 0; results[i]; i++ ) {
3488
					if ( results[i].nodeType === 1 ) {
3489
						tmp.push( results[i] );
3490
					}
3491
				}
3492
 
3493
				results = tmp;
3494
			}
3495
 
3496
			return results;
3497
		};
3498
	}
3499
 
3500
	// Check to see if an attribute returns normalized href attributes
3501
	div.innerHTML = "<a href='#'></a>";
3502
	if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
3503
			div.firstChild.getAttribute("href") !== "#" ) {
3504
		Expr.attrHandle.href = function(elem){
3505
			return elem.getAttribute("href", 2);
3506
		};
3507
	}
3508
 
3509
	div = null; // release memory in IE
3510
})();
3511
 
3512
if ( document.querySelectorAll ) {
3513
	(function(){
3514
		var oldSizzle = Sizzle, div = document.createElement("div");
3515
		div.innerHTML = "<p class='TEST'></p>";
3516
 
3517
		// Safari can't handle uppercase or unicode characters when
3518
		// in quirks mode.
3519
		if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
3520
			return;
3521
		}
3522
 
3523
		Sizzle = function(query, context, extra, seed){
3524
			context = context || document;
3525
 
3526
			// Only use querySelectorAll on non-XML documents
3527
			// (ID selectors don't work in non-HTML documents)
3528
			if ( !seed && context.nodeType === 9 && !isXML(context) ) {
3529
				try {
3530
					return makeArray( context.querySelectorAll(query), extra );
3531
				} catch(e){}
3532
			}
3533
 
3534
			return oldSizzle(query, context, extra, seed);
3535
		};
3536
 
3537
		for ( var prop in oldSizzle ) {
3538
			Sizzle[ prop ] = oldSizzle[ prop ];
3539
		}
3540
 
3541
		div = null; // release memory in IE
3542
	})();
3543
}
3544
 
3545
(function(){
3546
	var div = document.createElement("div");
3547
 
3548
	div.innerHTML = "<div class='test e'></div><div class='test'></div>";
3549
 
3550
	// Opera can't find a second classname (in 9.6)
3551
	// Also, make sure that getElementsByClassName actually exists
3552
	if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
3553
		return;
3554
	}
3555
 
3556
	// Safari caches class attributes, doesn't catch changes (in 3.2)
3557
	div.lastChild.className = "e";
3558
 
3559
	if ( div.getElementsByClassName("e").length === 1 ) {
3560
		return;
3561
	}
3562
 
3563
	Expr.order.splice(1, 0, "CLASS");
3564
	Expr.find.CLASS = function(match, context, isXML) {
3565
		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
3566
			return context.getElementsByClassName(match[1]);
3567
		}
3568
	};
3569
 
3570
	div = null; // release memory in IE
3571
})();
3572
 
3573
function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
3574
	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
3575
		var elem = checkSet[i];
3576
		if ( elem ) {
3577
			elem = elem[dir];
3578
			var match = false;
3579
 
3580
			while ( elem ) {
3581
				if ( elem.sizcache === doneName ) {
3582
					match = checkSet[elem.sizset];
3583
					break;
3584
				}
3585
 
3586
				if ( elem.nodeType === 1 && !isXML ){
3587
					elem.sizcache = doneName;
3588
					elem.sizset = i;
3589
				}
3590
 
3591
				if ( elem.nodeName.toLowerCase() === cur ) {
3592
					match = elem;
3593
					break;
3594
				}
3595
 
3596
				elem = elem[dir];
3597
			}
3598
 
3599
			checkSet[i] = match;
3600
		}
3601
	}
3602
}
3603
 
3604
function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
3605
	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
3606
		var elem = checkSet[i];
3607
		if ( elem ) {
3608
			elem = elem[dir];
3609
			var match = false;
3610
 
3611
			while ( elem ) {
3612
				if ( elem.sizcache === doneName ) {
3613
					match = checkSet[elem.sizset];
3614
					break;
3615
				}
3616
 
3617
				if ( elem.nodeType === 1 ) {
3618
					if ( !isXML ) {
3619
						elem.sizcache = doneName;
3620
						elem.sizset = i;
3621
					}
3622
					if ( typeof cur !== "string" ) {
3623
						if ( elem === cur ) {
3624
							match = true;
3625
							break;
3626
						}
3627
 
3628
					} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
3629
						match = elem;
3630
						break;
3631
					}
3632
				}
3633
 
3634
				elem = elem[dir];
3635
			}
3636
 
3637
			checkSet[i] = match;
3638
		}
3639
	}
3640
}
3641
 
3642
var contains = document.compareDocumentPosition ? function(a, b){
3643
	return !!(a.compareDocumentPosition(b) & 16);
3644
} : function(a, b){
3645
	return a !== b && (a.contains ? a.contains(b) : true);
3646
};
3647
 
3648
var isXML = function(elem){
3649
	// documentElement is verified for cases where it doesn't yet exist
3650
	// (such as loading iframes in IE - #4833)
3651
	var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
3652
	return documentElement ? documentElement.nodeName !== "HTML" : false;
3653
};
3654
 
3655
var posProcess = function(selector, context){
3656
	var tmpSet = [], later = "", match,
3657
		root = context.nodeType ? [context] : context;
3658
 
3659
	// Position selectors must be done after the filter
3660
	// And so must :not(positional) so we move all PSEUDOs to the end
3661
	while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
3662
		later += match[0];
3663
		selector = selector.replace( Expr.match.PSEUDO, "" );
3664
	}
3665
 
3666
	selector = Expr.relative[selector] ? selector + "*" : selector;
3667
 
3668
	for ( var i = 0, l = root.length; i < l; i++ ) {
3669
		Sizzle( selector, root[i], tmpSet );
3670
	}
3671
 
3672
	return Sizzle.filter( later, tmpSet );
3673
};
3674
 
3675
// EXPOSE
3676
jQuery.find = Sizzle;
3677
jQuery.expr = Sizzle.selectors;
3678
jQuery.expr[":"] = jQuery.expr.filters;
3679
jQuery.unique = Sizzle.uniqueSort;
3680
jQuery.text = getText;
3681
jQuery.isXMLDoc = isXML;
3682
jQuery.contains = contains;
3683
 
3684
return;
3685
 
3686
window.Sizzle = Sizzle;
3687
 
3688
})();
3689
var runtil = /Until$/,
3690
	rparentsprev = /^(?:parents|prevUntil|prevAll)/,
3691
	// Note: This RegExp should be improved, or likely pulled from Sizzle
3692
	rmultiselector = /,/,
3693
	slice = Array.prototype.slice;
3694
 
3695
// Implement the identical functionality for filter and not
3696
var winnow = function( elements, qualifier, keep ) {
3697
	if ( jQuery.isFunction( qualifier ) ) {
3698
		return jQuery.grep(elements, function( elem, i ) {
3699
			return !!qualifier.call( elem, i, elem ) === keep;
3700
		});
3701
 
3702
	} else if ( qualifier.nodeType ) {
3703
		return jQuery.grep(elements, function( elem, i ) {
3704
			return (elem === qualifier) === keep;
3705
		});
3706
 
3707
	} else if ( typeof qualifier === "string" ) {
3708
		var filtered = jQuery.grep(elements, function( elem ) {
3709
			return elem.nodeType === 1;
3710
		});
3711
 
3712
		if ( isSimple.test( qualifier ) ) {
3713
			return jQuery.filter(qualifier, filtered, !keep);
3714
		} else {
3715
			qualifier = jQuery.filter( qualifier, filtered );
3716
		}
3717
	}
3718
 
3719
	return jQuery.grep(elements, function( elem, i ) {
3720
		return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
3721
	});
3722
};
3723
 
3724
jQuery.fn.extend({
3725
	find: function( selector ) {
3726
		var ret = this.pushStack( "", "find", selector ), length = 0;
3727
 
3728
		for ( var i = 0, l = this.length; i < l; i++ ) {
3729
			length = ret.length;
3730
			jQuery.find( selector, this[i], ret );
3731
 
3732
			if ( i > 0 ) {
3733
				// Make sure that the results are unique
3734
				for ( var n = length; n < ret.length; n++ ) {
3735
					for ( var r = 0; r < length; r++ ) {
3736
						if ( ret[r] === ret[n] ) {
3737
							ret.splice(n--, 1);
3738
							break;
3739
						}
3740
					}
3741
				}
3742
			}
3743
		}
3744
 
3745
		return ret;
3746
	},
3747
 
3748
	has: function( target ) {
3749
		var targets = jQuery( target );
3750
		return this.filter(function() {
3751
			for ( var i = 0, l = targets.length; i < l; i++ ) {
3752
				if ( jQuery.contains( this, targets[i] ) ) {
3753
					return true;
3754
				}
3755
			}
3756
		});
3757
	},
3758
 
3759
	not: function( selector ) {
3760
		return this.pushStack( winnow(this, selector, false), "not", selector);
3761
	},
3762
 
3763
	filter: function( selector ) {
3764
		return this.pushStack( winnow(this, selector, true), "filter", selector );
3765
	},
3766
 
3767
	is: function( selector ) {
3768
		return !!selector && jQuery.filter( selector, this ).length > 0;
3769
	},
3770
 
3771
	closest: function( selectors, context ) {
3772
		if ( jQuery.isArray( selectors ) ) {
3773
			var ret = [], cur = this[0], match, matches = {}, selector;
3774
 
3775
			if ( cur && selectors.length ) {
3776
				for ( var i = 0, l = selectors.length; i < l; i++ ) {
3777
					selector = selectors[i];
3778
 
3779
					if ( !matches[selector] ) {
3780
						matches[selector] = jQuery.expr.match.POS.test( selector ) ?
3781
							jQuery( selector, context || this.context ) :
3782
							selector;
3783
					}
3784
				}
3785
 
3786
				while ( cur && cur.ownerDocument && cur !== context ) {
3787
					for ( selector in matches ) {
3788
						match = matches[selector];
3789
 
3790
						if ( match.jquery ? match.index(cur) > -1 : jQuery(cur).is(match) ) {
3791
							ret.push({ selector: selector, elem: cur });
3792
							delete matches[selector];
3793
						}
3794
					}
3795
					cur = cur.parentNode;
3796
				}
3797
			}
3798
 
3799
			return ret;
3800
		}
3801
 
3802
		var pos = jQuery.expr.match.POS.test( selectors ) ?
3803
			jQuery( selectors, context || this.context ) : null;
3804
 
3805
		return this.map(function( i, cur ) {
3806
			while ( cur && cur.ownerDocument && cur !== context ) {
3807
				if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selectors) ) {
3808
					return cur;
3809
				}
3810
				cur = cur.parentNode;
3811
			}
3812
			return null;
3813
		});
3814
	},
3815
 
3816
	// Determine the position of an element within
3817
	// the matched set of elements
3818
	index: function( elem ) {
3819
		if ( !elem || typeof elem === "string" ) {
3820
			return jQuery.inArray( this[0],
3821
				// If it receives a string, the selector is used
3822
				// If it receives nothing, the siblings are used
3823
				elem ? jQuery( elem ) : this.parent().children() );
3824
		}
3825
		// Locate the position of the desired element
3826
		return jQuery.inArray(
3827
			// If it receives a jQuery object, the first element is used
3828
			elem.jquery ? elem[0] : elem, this );
3829
	},
3830
 
3831
	add: function( selector, context ) {
3832
		var set = typeof selector === "string" ?
3833
				jQuery( selector, context || this.context ) :
3834
				jQuery.makeArray( selector ),
3835
			all = jQuery.merge( this.get(), set );
3836
 
3837
		return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
3838
			all :
3839
			jQuery.unique( all ) );
3840
	},
3841
 
3842
	andSelf: function() {
3843
		return this.add( this.prevObject );
3844
	}
3845
});
3846
 
3847
// A painfully simple check to see if an element is disconnected
3848
// from a document (should be improved, where feasible).
3849
function isDisconnected( node ) {
3850
	return !node || !node.parentNode || node.parentNode.nodeType === 11;
3851
}
3852
 
3853
jQuery.each({
3854
	parent: function( elem ) {
3855
		var parent = elem.parentNode;
3856
		return parent && parent.nodeType !== 11 ? parent : null;
3857
	},
3858
	parents: function( elem ) {
3859
		return jQuery.dir( elem, "parentNode" );
3860
	},
3861
	parentsUntil: function( elem, i, until ) {
3862
		return jQuery.dir( elem, "parentNode", until );
3863
	},
3864
	next: function( elem ) {
3865
		return jQuery.nth( elem, 2, "nextSibling" );
3866
	},
3867
	prev: function( elem ) {
3868
		return jQuery.nth( elem, 2, "previousSibling" );
3869
	},
3870
	nextAll: function( elem ) {
3871
		return jQuery.dir( elem, "nextSibling" );
3872
	},
3873
	prevAll: function( elem ) {
3874
		return jQuery.dir( elem, "previousSibling" );
3875
	},
3876
	nextUntil: function( elem, i, until ) {
3877
		return jQuery.dir( elem, "nextSibling", until );
3878
	},
3879
	prevUntil: function( elem, i, until ) {
3880
		return jQuery.dir( elem, "previousSibling", until );
3881
	},
3882
	siblings: function( elem ) {
3883
		return jQuery.sibling( elem.parentNode.firstChild, elem );
3884
	},
3885
	children: function( elem ) {
3886
		return jQuery.sibling( elem.firstChild );
3887
	},
3888
	contents: function( elem ) {
3889
		return jQuery.nodeName( elem, "iframe" ) ?
3890
			elem.contentDocument || elem.contentWindow.document :
3891
			jQuery.makeArray( elem.childNodes );
3892
	}
3893
}, function( name, fn ) {
3894
	jQuery.fn[ name ] = function( until, selector ) {
3895
		var ret = jQuery.map( this, fn, until );
3896
 
3897
		if ( !runtil.test( name ) ) {
3898
			selector = until;
3899
		}
3900
 
3901
		if ( selector && typeof selector === "string" ) {
3902
			ret = jQuery.filter( selector, ret );
3903
		}
3904
 
3905
		ret = this.length > 1 ? jQuery.unique( ret ) : ret;
3906
 
3907
		if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
3908
			ret = ret.reverse();
3909
		}
3910
 
3911
		return this.pushStack( ret, name, slice.call(arguments).join(",") );
3912
	};
3913
});
3914
 
3915
jQuery.extend({
3916
	filter: function( expr, elems, not ) {
3917
		if ( not ) {
3918
			expr = ":not(" + expr + ")";
3919
		}
3920
 
3921
		return jQuery.find.matches(expr, elems);
3922
	},
3923
 
3924
	dir: function( elem, dir, until ) {
3925
		var matched = [], cur = elem[dir];
3926
		while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
3927
			if ( cur.nodeType === 1 ) {
3928
				matched.push( cur );
3929
			}
3930
			cur = cur[dir];
3931
		}
3932
		return matched;
3933
	},
3934
 
3935
	nth: function( cur, result, dir, elem ) {
3936
		result = result || 1;
3937
		var num = 0;
3938
 
3939
		for ( ; cur; cur = cur[dir] ) {
3940
			if ( cur.nodeType === 1 && ++num === result ) {
3941
				break;
3942
			}
3943
		}
3944
 
3945
		return cur;
3946
	},
3947
 
3948
	sibling: function( n, elem ) {
3949
		var r = [];
3950
 
3951
		for ( ; n; n = n.nextSibling ) {
3952
			if ( n.nodeType === 1 && n !== elem ) {
3953
				r.push( n );
3954
			}
3955
		}
3956
 
3957
		return r;
3958
	}
3959
});
3960
var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
3961
	rleadingWhitespace = /^\s+/,
3962
	rxhtmlTag = /(<([\w:]+)[^>]*?)\/>/g,
3963
	rselfClosing = /^(?:area|br|col|embed|hr|img|input|link|meta|param)$/i,
3964
	rtagName = /<([\w:]+)/,
3965
	rtbody = /<tbody/i,
3966
	rhtml = /<|&#?\w+;/,
3967
	rnocache = /<script|<object|<embed|<option|<style/i,
3968
	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,  // checked="checked" or checked (html5)
3969
	fcloseTag = function( all, front, tag ) {
3970
		return rselfClosing.test( tag ) ?
3971
			all :
3972
			front + "></" + tag + ">";
3973
	},
3974
	wrapMap = {
3975
		option: [ 1, "<select multiple='multiple'>", "</select>" ],
3976
		legend: [ 1, "<fieldset>", "</fieldset>" ],
3977
		thead: [ 1, "<table>", "</table>" ],
3978
		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
3979
		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
3980
		col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
3981
		area: [ 1, "<map>", "</map>" ],
3982
		_default: [ 0, "", "" ]
3983
	};
3984
 
3985
wrapMap.optgroup = wrapMap.option;
3986
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
3987
wrapMap.th = wrapMap.td;
3988
 
3989
// IE can't serialize <link> and <script> tags normally
3990
if ( !jQuery.support.htmlSerialize ) {
3991
	wrapMap._default = [ 1, "div<div>", "</div>" ];
3992
}
3993
 
3994
jQuery.fn.extend({
3995
	text: function( text ) {
3996
		if ( jQuery.isFunction(text) ) {
3997
			return this.each(function(i) {
3998
				var self = jQuery(this);
3999
				self.text( text.call(this, i, self.text()) );
4000
			});
4001
		}
4002
 
4003
		if ( typeof text !== "object" && text !== undefined ) {
4004
			return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
4005
		}
4006
 
4007
		return jQuery.text( this );
4008
	},
4009
 
4010
	wrapAll: function( html ) {
4011
		if ( jQuery.isFunction( html ) ) {
4012
			return this.each(function(i) {
4013
				jQuery(this).wrapAll( html.call(this, i) );
4014
			});
4015
		}
4016
 
4017
		if ( this[0] ) {
4018
			// The elements to wrap the target around
4019
			var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
4020
 
4021
			if ( this[0].parentNode ) {
4022
				wrap.insertBefore( this[0] );
4023
			}
4024
 
4025
			wrap.map(function() {
4026
				var elem = this;
4027
 
4028
				while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
4029
					elem = elem.firstChild;
4030
				}
4031
 
4032
				return elem;
4033
			}).append(this);
4034
		}
4035
 
4036
		return this;
4037
	},
4038
 
4039
	wrapInner: function( html ) {
4040
		if ( jQuery.isFunction( html ) ) {
4041
			return this.each(function(i) {
4042
				jQuery(this).wrapInner( html.call(this, i) );
4043
			});
4044
		}
4045
 
4046
		return this.each(function() {
4047
			var self = jQuery( this ), contents = self.contents();
4048
 
4049
			if ( contents.length ) {
4050
				contents.wrapAll( html );
4051
 
4052
			} else {
4053
				self.append( html );
4054
			}
4055
		});
4056
	},
4057
 
4058
	wrap: function( html ) {
4059
		return this.each(function() {
4060
			jQuery( this ).wrapAll( html );
4061
		});
4062
	},
4063
 
4064
	unwrap: function() {
4065
		return this.parent().each(function() {
4066
			if ( !jQuery.nodeName( this, "body" ) ) {
4067
				jQuery( this ).replaceWith( this.childNodes );
4068
			}
4069
		}).end();
4070
	},
4071
 
4072
	append: function() {
4073
		return this.domManip(arguments, true, function( elem ) {
4074
			if ( this.nodeType === 1 ) {
4075
				this.appendChild( elem );
4076
			}
4077
		});
4078
	},
4079
 
4080
	prepend: function() {
4081
		return this.domManip(arguments, true, function( elem ) {
4082
			if ( this.nodeType === 1 ) {
4083
				this.insertBefore( elem, this.firstChild );
4084
			}
4085
		});
4086
	},
4087
 
4088
	before: function() {
4089
		if ( this[0] && this[0].parentNode ) {
4090
			return this.domManip(arguments, false, function( elem ) {
4091
				this.parentNode.insertBefore( elem, this );
4092
			});
4093
		} else if ( arguments.length ) {
4094
			var set = jQuery(arguments[0]);
4095
			set.push.apply( set, this.toArray() );
4096
			return this.pushStack( set, "before", arguments );
4097
		}
4098
	},
4099
 
4100
	after: function() {
4101
		if ( this[0] && this[0].parentNode ) {
4102
			return this.domManip(arguments, false, function( elem ) {
4103
				this.parentNode.insertBefore( elem, this.nextSibling );
4104
			});
4105
		} else if ( arguments.length ) {
4106
			var set = this.pushStack( this, "after", arguments );
4107
			set.push.apply( set, jQuery(arguments[0]).toArray() );
4108
			return set;
4109
		}
4110
	},
4111
 
4112
	// keepData is for internal use only--do not document
4113
	remove: function( selector, keepData ) {
4114
		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
4115
			if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
4116
				if ( !keepData && elem.nodeType === 1 ) {
4117
					jQuery.cleanData( elem.getElementsByTagName("*") );
4118
					jQuery.cleanData( [ elem ] );
4119
				}
4120
 
4121
				if ( elem.parentNode ) {
4122
					 elem.parentNode.removeChild( elem );
4123
				}
4124
			}
4125
		}
4126
 
4127
		return this;
4128
	},
4129
 
4130
	empty: function() {
4131
		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
4132
			// Remove element nodes and prevent memory leaks
4133
			if ( elem.nodeType === 1 ) {
4134
				jQuery.cleanData( elem.getElementsByTagName("*") );
4135
			}
4136
 
4137
			// Remove any remaining nodes
4138
			while ( elem.firstChild ) {
4139
				elem.removeChild( elem.firstChild );
4140
			}
4141
		}
4142
 
4143
		return this;
4144
	},
4145
 
4146
	clone: function( events ) {
4147
		// Do the clone
4148
		var ret = this.map(function() {
4149
			if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
4150
				// IE copies events bound via attachEvent when
4151
				// using cloneNode. Calling detachEvent on the
4152
				// clone will also remove the events from the orignal
4153
				// In order to get around this, we use innerHTML.
4154
				// Unfortunately, this means some modifications to
4155
				// attributes in IE that are actually only stored
4156
				// as properties will not be copied (such as the
4157
				// the name attribute on an input).
4158
				var html = this.outerHTML, ownerDocument = this.ownerDocument;
4159
				if ( !html ) {
4160
					var div = ownerDocument.createElement("div");
4161
					div.appendChild( this.cloneNode(true) );
4162
					html = div.innerHTML;
4163
				}
4164
 
4165
				return jQuery.clean([html.replace(rinlinejQuery, "")
4166
					// Handle the case in IE 8 where action=/test/> self-closes a tag
4167
					.replace(/=([^="'>\s]+\/)>/g, '="$1">')
4168
					.replace(rleadingWhitespace, "")], ownerDocument)[0];
4169
			} else {
4170
				return this.cloneNode(true);
4171
			}
4172
		});
4173
 
4174
		// Copy the events from the original to the clone
4175
		if ( events === true ) {
4176
			cloneCopyEvent( this, ret );
4177
			cloneCopyEvent( this.find("*"), ret.find("*") );
4178
		}
4179
 
4180
		// Return the cloned set
4181
		return ret;
4182
	},
4183
 
4184
	html: function( value ) {
4185
		if ( value === undefined ) {
4186
			return this[0] && this[0].nodeType === 1 ?
4187
				this[0].innerHTML.replace(rinlinejQuery, "") :
4188
				null;
4189
 
4190
		// See if we can take a shortcut and just use innerHTML
4191
		} else if ( typeof value === "string" && !rnocache.test( value ) &&
4192
			(jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
4193
			!wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
4194
 
4195
			value = value.replace(rxhtmlTag, fcloseTag);
4196
 
4197
			try {
4198
				for ( var i = 0, l = this.length; i < l; i++ ) {
4199
					// Remove element nodes and prevent memory leaks
4200
					if ( this[i].nodeType === 1 ) {
4201
						jQuery.cleanData( this[i].getElementsByTagName("*") );
4202
						this[i].innerHTML = value;
4203
					}
4204
				}
4205
 
4206
			// If using innerHTML throws an exception, use the fallback method
4207
			} catch(e) {
4208
				this.empty().append( value );
4209
			}
4210
 
4211
		} else if ( jQuery.isFunction( value ) ) {
4212
			this.each(function(i){
4213
				var self = jQuery(this), old = self.html();
4214
				self.empty().append(function(){
4215
					return value.call( this, i, old );
4216
				});
4217
			});
4218
 
4219
		} else {
4220
			this.empty().append( value );
4221
		}
4222
 
4223
		return this;
4224
	},
4225
 
4226
	replaceWith: function( value ) {
4227
		if ( this[0] && this[0].parentNode ) {
4228
			// Make sure that the elements are removed from the DOM before they are inserted
4229
			// this can help fix replacing a parent with child elements
4230
			if ( jQuery.isFunction( value ) ) {
4231
				return this.each(function(i) {
4232
					var self = jQuery(this), old = self.html();
4233
					self.replaceWith( value.call( this, i, old ) );
4234
				});
4235
			}
4236
 
4237
			if ( typeof value !== "string" ) {
4238
				value = jQuery(value).detach();
4239
			}
4240
 
4241
			return this.each(function() {
4242
				var next = this.nextSibling, parent = this.parentNode;
4243
 
4244
				jQuery(this).remove();
4245
 
4246
				if ( next ) {
4247
					jQuery(next).before( value );
4248
				} else {
4249
					jQuery(parent).append( value );
4250
				}
4251
			});
4252
		} else {
4253
			return this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value );
4254
		}
4255
	},
4256
 
4257
	detach: function( selector ) {
4258
		return this.remove( selector, true );
4259
	},
4260
 
4261
	domManip: function( args, table, callback ) {
4262
		var results, first, value = args[0], scripts = [], fragment, parent;
4263
 
4264
		// We can't cloneNode fragments that contain checked, in WebKit
4265
		if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
4266
			return this.each(function() {
4267
				jQuery(this).domManip( args, table, callback, true );
4268
			});
4269
		}
4270
 
4271
		if ( jQuery.isFunction(value) ) {
4272
			return this.each(function(i) {
4273
				var self = jQuery(this);
4274
				args[0] = value.call(this, i, table ? self.html() : undefined);
4275
				self.domManip( args, table, callback );
4276
			});
4277
		}
4278
 
4279
		if ( this[0] ) {
4280
			parent = value && value.parentNode;
4281
 
4282
			// If we're in a fragment, just use that instead of building a new one
4283
			if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
4284
				results = { fragment: parent };
4285
 
4286
			} else {
4287
				results = buildFragment( args, this, scripts );
4288
			}
4289
 
4290
			fragment = results.fragment;
4291
 
4292
			if ( fragment.childNodes.length === 1 ) {
4293
				first = fragment = fragment.firstChild;
4294
			} else {
4295
				first = fragment.firstChild;
4296
			}
4297
 
4298
			if ( first ) {
4299
				table = table && jQuery.nodeName( first, "tr" );
4300
 
4301
				for ( var i = 0, l = this.length; i < l; i++ ) {
4302
					callback.call(
4303
						table ?
4304
							root(this[i], first) :
4305
							this[i],
4306
						i > 0 || results.cacheable || this.length > 1  ?
4307
							fragment.cloneNode(true) :
4308
							fragment
4309
					);
4310
				}
4311
			}
4312
 
4313
			if ( scripts.length ) {
4314
				jQuery.each( scripts, evalScript );
4315
			}
4316
		}
4317
 
4318
		return this;
4319
 
4320
		function root( elem, cur ) {
4321
			return jQuery.nodeName(elem, "table") ?
4322
				(elem.getElementsByTagName("tbody")[0] ||
4323
				elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
4324
				elem;
4325
		}
4326
	}
4327
});
4328
 
4329
function cloneCopyEvent(orig, ret) {
4330
	var i = 0;
4331
 
4332
	ret.each(function() {
4333
		if ( this.nodeName !== (orig[i] && orig[i].nodeName) ) {
4334
			return;
4335
		}
4336
 
4337
		var oldData = jQuery.data( orig[i++] ), curData = jQuery.data( this, oldData ), events = oldData && oldData.events;
4338
 
4339
		if ( events ) {
4340
			delete curData.handle;
4341
			curData.events = {};
4342
 
4343
			for ( var type in events ) {
4344
				for ( var handler in events[ type ] ) {
4345
					jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
4346
				}
4347
			}
4348
		}
4349
	});
4350
}
4351
 
4352
function buildFragment( args, nodes, scripts ) {
4353
	var fragment, cacheable, cacheresults,
4354
		doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
4355
 
4356
	// Only cache "small" (1/2 KB) strings that are associated with the main document
4357
	// Cloning options loses the selected state, so don't cache them
4358
	// IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
4359
	// Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
4360
	if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
4361
		!rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
4362
 
4363
		cacheable = true;
4364
		cacheresults = jQuery.fragments[ args[0] ];
4365
		if ( cacheresults ) {
4366
			if ( cacheresults !== 1 ) {
4367
				fragment = cacheresults;
4368
			}
4369
		}
4370
	}
4371
 
4372
	if ( !fragment ) {
4373
		fragment = doc.createDocumentFragment();
4374
		jQuery.clean( args, doc, fragment, scripts );
4375
	}
4376
 
4377
	if ( cacheable ) {
4378
		jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
4379
	}
4380
 
4381
	return { fragment: fragment, cacheable: cacheable };
4382
}
4383
 
4384
jQuery.fragments = {};
4385
 
4386
jQuery.each({
4387
	appendTo: "append",
4388
	prependTo: "prepend",
4389
	insertBefore: "before",
4390
	insertAfter: "after",
4391
	replaceAll: "replaceWith"
4392
}, function( name, original ) {
4393
	jQuery.fn[ name ] = function( selector ) {
4394
		var ret = [], insert = jQuery( selector ),
4395
			parent = this.length === 1 && this[0].parentNode;
4396
 
4397
		if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
4398
			insert[ original ]( this[0] );
4399
			return this;
4400
 
4401
		} else {
4402
			for ( var i = 0, l = insert.length; i < l; i++ ) {
4403
				var elems = (i > 0 ? this.clone(true) : this).get();
4404
				jQuery.fn[ original ].apply( jQuery(insert[i]), elems );
4405
				ret = ret.concat( elems );
4406
			}
4407
 
4408
			return this.pushStack( ret, name, insert.selector );
4409
		}
4410
	};
4411
});
4412
 
4413
jQuery.extend({
4414
	clean: function( elems, context, fragment, scripts ) {
4415
		context = context || document;
4416
 
4417
		// !context.createElement fails in IE with an error but returns typeof 'object'
4418
		if ( typeof context.createElement === "undefined" ) {
4419
			context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
4420
		}
4421
 
4422
		var ret = [];
4423
 
4424
		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
4425
			if ( typeof elem === "number" ) {
4426
				elem += "";
4427
			}
4428
 
4429
			if ( !elem ) {
4430
				continue;
4431
			}
4432
 
4433
			// Convert html string into DOM nodes
4434
			if ( typeof elem === "string" && !rhtml.test( elem ) ) {
4435
				elem = context.createTextNode( elem );
4436
 
4437
			} else if ( typeof elem === "string" ) {
4438
				// Fix "XHTML"-style tags in all browsers
4439
				elem = elem.replace(rxhtmlTag, fcloseTag);
4440
 
4441
				// Trim whitespace, otherwise indexOf won't work as expected
4442
				var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
4443
					wrap = wrapMap[ tag ] || wrapMap._default,
4444
					depth = wrap[0],
4445
					div = context.createElement("div");
4446
 
4447
				// Go to html and back, then peel off extra wrappers
4448
				div.innerHTML = wrap[1] + elem + wrap[2];
4449
 
4450
				// Move to the right depth
4451
				while ( depth-- ) {
4452
					div = div.lastChild;
4453
				}
4454
 
4455
				// Remove IE's autoinserted <tbody> from table fragments
4456
				if ( !jQuery.support.tbody ) {
4457
 
4458
					// String was a <table>, *may* have spurious <tbody>
4459
					var hasBody = rtbody.test(elem),
4460
						tbody = tag === "table" && !hasBody ?
4461
							div.firstChild && div.firstChild.childNodes :
4462
 
4463
							// String was a bare <thead> or <tfoot>
4464
							wrap[1] === "<table>" && !hasBody ?
4465
								div.childNodes :
4466
								[];
4467
 
4468
					for ( var j = tbody.length - 1; j >= 0 ; --j ) {
4469
						if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
4470
							tbody[ j ].parentNode.removeChild( tbody[ j ] );
4471
						}
4472
					}
4473
 
4474
				}
4475
 
4476
				// IE completely kills leading whitespace when innerHTML is used
4477
				if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
4478
					div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
4479
				}
4480
 
4481
				elem = div.childNodes;
4482
			}
4483
 
4484
			if ( elem.nodeType ) {
4485
				ret.push( elem );
4486
			} else {
4487
				ret = jQuery.merge( ret, elem );
4488
			}
4489
		}
4490
 
4491
		if ( fragment ) {
4492
			for ( var i = 0; ret[i]; i++ ) {
4493
				if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
4494
					scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
4495
 
4496
				} else {
4497
					if ( ret[i].nodeType === 1 ) {
4498
						ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
4499
					}
4500
					fragment.appendChild( ret[i] );
4501
				}
4502
			}
4503
		}
4504
 
4505
		return ret;
4506
	},
4507
 
4508
	cleanData: function( elems ) {
4509
		var data, id, cache = jQuery.cache,
4510
			special = jQuery.event.special,
4511
			deleteExpando = jQuery.support.deleteExpando;
4512
 
4513
		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
4514
			id = elem[ jQuery.expando ];
4515
 
4516
			if ( id ) {
4517
				data = cache[ id ];
4518
 
4519
				if ( data.events ) {
4520
					for ( var type in data.events ) {
4521
						if ( special[ type ] ) {
4522
							jQuery.event.remove( elem, type );
4523
 
4524
						} else {
4525
							removeEvent( elem, type, data.handle );
4526
						}
4527
					}
4528
				}
4529
 
4530
				if ( deleteExpando ) {
4531
					delete elem[ jQuery.expando ];
4532
 
4533
				} else if ( elem.removeAttribute ) {
4534
					elem.removeAttribute( jQuery.expando );
4535
				}
4536
 
4537
				delete cache[ id ];
4538
			}
4539
		}
4540
	}
4541
});
4542
// exclude the following css properties to add px
4543
var rexclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
4544
	ralpha = /alpha\([^)]*\)/,
4545
	ropacity = /opacity=([^)]*)/,
4546
	rfloat = /float/i,
4547
	rdashAlpha = /-([a-z])/ig,
4548
	rupper = /([A-Z])/g,
4549
	rnumpx = /^-?\d+(?:px)?$/i,
4550
	rnum = /^-?\d/,
4551
 
4552
	cssShow = { position: "absolute", visibility: "hidden", display:"block" },
4553
	cssWidth = [ "Left", "Right" ],
4554
	cssHeight = [ "Top", "Bottom" ],
4555
 
4556
	// cache check for defaultView.getComputedStyle
4557
	getComputedStyle = document.defaultView && document.defaultView.getComputedStyle,
4558
	// normalize float css property
4559
	styleFloat = jQuery.support.cssFloat ? "cssFloat" : "styleFloat",
4560
	fcamelCase = function( all, letter ) {
4561
		return letter.toUpperCase();
4562
	};
4563
 
4564
jQuery.fn.css = function( name, value ) {
4565
	return access( this, name, value, true, function( elem, name, value ) {
4566
		if ( value === undefined ) {
4567
			return jQuery.curCSS( elem, name );
4568
		}
4569
 
4570
		if ( typeof value === "number" && !rexclude.test(name) ) {
4571
			value += "px";
4572
		}
4573
 
4574
		jQuery.style( elem, name, value );
4575
	});
4576
};
4577
 
4578
jQuery.extend({
4579
	style: function( elem, name, value ) {
4580
		// don't set styles on text and comment nodes
4581
		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
4582
			return undefined;
4583
		}
4584
 
4585
		// ignore negative width and height values #1599
4586
		if ( (name === "width" || name === "height") && parseFloat(value) < 0 ) {
4587
			value = undefined;
4588
		}
4589
 
4590
		var style = elem.style || elem, set = value !== undefined;
4591
 
4592
		// IE uses filters for opacity
4593
		if ( !jQuery.support.opacity && name === "opacity" ) {
4594
			if ( set ) {
4595
				// IE has trouble with opacity if it does not have layout
4596
				// Force it by setting the zoom level
4597
				style.zoom = 1;
4598
 
4599
				// Set the alpha filter to set the opacity
4600
				var opacity = parseInt( value, 10 ) + "" === "NaN" ? "" : "alpha(opacity=" + value * 100 + ")";
4601
				var filter = style.filter || jQuery.curCSS( elem, "filter" ) || "";
4602
				style.filter = ralpha.test(filter) ? filter.replace(ralpha, opacity) : opacity;
4603
			}
4604
 
4605
			return style.filter && style.filter.indexOf("opacity=") >= 0 ?
4606
				(parseFloat( ropacity.exec(style.filter)[1] ) / 100) + "":
4607
				"";
4608
		}
4609
 
4610
		// Make sure we're using the right name for getting the float value
4611
		if ( rfloat.test( name ) ) {
4612
			name = styleFloat;
4613
		}
4614
 
4615
		name = name.replace(rdashAlpha, fcamelCase);
4616
 
4617
		if ( set ) {
4618
			style[ name ] = value;
4619
		}
4620
 
4621
		return style[ name ];
4622
	},
4623
 
4624
	css: function( elem, name, force, extra ) {
4625
		if ( name === "width" || name === "height" ) {
4626
			var val, props = cssShow, which = name === "width" ? cssWidth : cssHeight;
4627
 
4628
			function getWH() {
4629
				val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
4630
 
4631
				if ( extra === "border" ) {
4632
					return;
4633
				}
4634
 
4635
				jQuery.each( which, function() {
4636
					if ( !extra ) {
4637
						val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
4638
					}
4639
 
4640
					if ( extra === "margin" ) {
4641
						val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0;
4642
					} else {
4643
						val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
4644
					}
4645
				});
4646
			}
4647
 
4648
			if ( elem.offsetWidth !== 0 ) {
4649
				getWH();
4650
			} else {
4651
				jQuery.swap( elem, props, getWH );
4652
			}
4653
 
4654
			return Math.max(0, Math.round(val));
4655
		}
4656
 
4657
		return jQuery.curCSS( elem, name, force );
4658
	},
4659
 
4660
	curCSS: function( elem, name, force ) {
4661
		var ret, style = elem.style, filter;
4662
 
4663
		// IE uses filters for opacity
4664
		if ( !jQuery.support.opacity && name === "opacity" && elem.currentStyle ) {
4665
			ret = ropacity.test(elem.currentStyle.filter || "") ?
4666
				(parseFloat(RegExp.$1) / 100) + "" :
4667
				"";
4668
 
4669
			return ret === "" ?
4670
				"1" :
4671
				ret;
4672
		}
4673
 
4674
		// Make sure we're using the right name for getting the float value
4675
		if ( rfloat.test( name ) ) {
4676
			name = styleFloat;
4677
		}
4678
 
4679
		if ( !force && style && style[ name ] ) {
4680
			ret = style[ name ];
4681
 
4682
		} else if ( getComputedStyle ) {
4683
 
4684
			// Only "float" is needed here
4685
			if ( rfloat.test( name ) ) {
4686
				name = "float";
4687
			}
4688
 
4689
			name = name.replace( rupper, "-$1" ).toLowerCase();
4690
 
4691
			var defaultView = elem.ownerDocument.defaultView;
4692
 
4693
			if ( !defaultView ) {
4694
				return null;
4695
			}
4696
 
4697
			var computedStyle = defaultView.getComputedStyle( elem, null );
4698
 
4699
			if ( computedStyle ) {
4700
				ret = computedStyle.getPropertyValue( name );
4701
			}
4702
 
4703
			// We should always get a number back from opacity
4704
			if ( name === "opacity" && ret === "" ) {
4705
				ret = "1";
4706
			}
4707
 
4708
		} else if ( elem.currentStyle ) {
4709
			var camelCase = name.replace(rdashAlpha, fcamelCase);
4710
 
4711
			ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
4712
 
4713
			// From the awesome hack by Dean Edwards
4714
			// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
4715
 
4716
			// If we're not dealing with a regular pixel number
4717
			// but a number that has a weird ending, we need to convert it to pixels
4718
			if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
4719
				// Remember the original values
4720
				var left = style.left, rsLeft = elem.runtimeStyle.left;
4721
 
4722
				// Put in the new values to get a computed value out
4723
				elem.runtimeStyle.left = elem.currentStyle.left;
4724
				style.left = camelCase === "fontSize" ? "1em" : (ret || 0);
4725
				ret = style.pixelLeft + "px";
4726
 
4727
				// Revert the changed values
4728
				style.left = left;
4729
				elem.runtimeStyle.left = rsLeft;
4730
			}
4731
		}
4732
 
4733
		return ret;
4734
	},
4735
 
4736
	// A method for quickly swapping in/out CSS properties to get correct calculations
4737
	swap: function( elem, options, callback ) {
4738
		var old = {};
4739
 
4740
		// Remember the old values, and insert the new ones
4741
		for ( var name in options ) {
4742
			old[ name ] = elem.style[ name ];
4743
			elem.style[ name ] = options[ name ];
4744
		}
4745
 
4746
		callback.call( elem );
4747
 
4748
		// Revert the old values
4749
		for ( var name in options ) {
4750
			elem.style[ name ] = old[ name ];
4751
		}
4752
	}
4753
});
4754
 
4755
if ( jQuery.expr && jQuery.expr.filters ) {
4756
	jQuery.expr.filters.hidden = function( elem ) {
4757
		var width = elem.offsetWidth, height = elem.offsetHeight,
4758
			skip = elem.nodeName.toLowerCase() === "tr";
4759
 
4760
		return width === 0 && height === 0 && !skip ?
4761
			true :
4762
			width > 0 && height > 0 && !skip ?
4763
				false :
4764
				jQuery.curCSS(elem, "display") === "none";
4765
	};
4766
 
4767
	jQuery.expr.filters.visible = function( elem ) {
4768
		return !jQuery.expr.filters.hidden( elem );
4769
	};
4770
}
4771
var jsc = now(),
4772
	rscript = /<script(.|\s)*?\/script>/gi,
4773
	rselectTextarea = /select|textarea/i,
4774
	rinput = /color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week/i,
4775
	jsre = /=\?(&|$)/,
4776
	rquery = /\?/,
4777
	rts = /(\?|&)_=.*?(&|$)/,
4778
	rurl = /^(\w+:)?\/\/([^\/?#]+)/,
4779
	r20 = /%20/g,
4780
 
4781
	// Keep a copy of the old load method
4782
	_load = jQuery.fn.load;
4783
 
4784
jQuery.fn.extend({
4785
	load: function( url, params, callback ) {
4786
		if ( typeof url !== "string" ) {
4787
			return _load.call( this, url );
4788
 
4789
		// Don't do a request if no elements are being requested
4790
		} else if ( !this.length ) {
4791
			return this;
4792
		}
4793
 
4794
		var off = url.indexOf(" ");
4795
		if ( off >= 0 ) {
4796
			var selector = url.slice(off, url.length);
4797
			url = url.slice(0, off);
4798
		}
4799
 
4800
		// Default to a GET request
4801
		var type = "GET";
4802
 
4803
		// If the second parameter was provided
4804
		if ( params ) {
4805
			// If it's a function
4806
			if ( jQuery.isFunction( params ) ) {
4807
				// We assume that it's the callback
4808
				callback = params;
4809
				params = null;
4810
 
4811
			// Otherwise, build a param string
4812
			} else if ( typeof params === "object" ) {
4813
				params = jQuery.param( params, jQuery.ajaxSettings.traditional );
4814
				type = "POST";
4815
			}
4816
		}
4817
 
4818
		var self = this;
4819
 
4820
		// Request the remote document
4821
		jQuery.ajax({
4822
			url: url,
4823
			type: type,
4824
			dataType: "html",
4825
			data: params,
4826
			complete: function( res, status ) {
4827
				// If successful, inject the HTML into all the matched elements
4828
				if ( status === "success" || status === "notmodified" ) {
4829
					// See if a selector was specified
4830
					self.html( selector ?
4831
						// Create a dummy div to hold the results
4832
						jQuery("<div />")
4833
							// inject the contents of the document in, removing the scripts
4834
							// to avoid any 'Permission Denied' errors in IE
4835
							.append(res.responseText.replace(rscript, ""))
4836
 
4837
							// Locate the specified elements
4838
							.find(selector) :
4839
 
4840
						// If not, just inject the full result
4841
						res.responseText );
4842
				}
4843
 
4844
				if ( callback ) {
4845
					self.each( callback, [res.responseText, status, res] );
4846
				}
4847
			}
4848
		});
4849
 
4850
		return this;
4851
	},
4852
 
4853
	serialize: function() {
4854
		return jQuery.param(this.serializeArray());
4855
	},
4856
	serializeArray: function() {
4857
		return this.map(function() {
4858
			return this.elements ? jQuery.makeArray(this.elements) : this;
4859
		})
4860
		.filter(function() {
4861
			return this.name && !this.disabled &&
4862
				(this.checked || rselectTextarea.test(this.nodeName) ||
4863
					rinput.test(this.type));
4864
		})
4865
		.map(function( i, elem ) {
4866
			var val = jQuery(this).val();
4867
 
4868
			return val == null ?
4869
				null :
4870
				jQuery.isArray(val) ?
4871
					jQuery.map( val, function( val, i ) {
4872
						return { name: elem.name, value: val };
4873
					}) :
4874
					{ name: elem.name, value: val };
4875
		}).get();
4876
	}
4877
});
4878
 
4879
// Attach a bunch of functions for handling common AJAX events
4880
jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function( i, o ) {
4881
	jQuery.fn[o] = function( f ) {
4882
		return this.bind(o, f);
4883
	};
4884
});
4885
 
4886
jQuery.extend({
4887
 
4888
	get: function( url, data, callback, type ) {
4889
		// shift arguments if data argument was omited
4890
		if ( jQuery.isFunction( data ) ) {
4891
			type = type || callback;
4892
			callback = data;
4893
			data = null;
4894
		}
4895
 
4896
		return jQuery.ajax({
4897
			type: "GET",
4898
			url: url,
4899
			data: data,
4900
			success: callback,
4901
			dataType: type
4902
		});
4903
	},
4904
 
4905
	getScript: function( url, callback ) {
4906
		return jQuery.get(url, null, callback, "script");
4907
	},
4908
 
4909
	getJSON: function( url, data, callback ) {
4910
		return jQuery.get(url, data, callback, "json");
4911
	},
4912
 
4913
	post: function( url, data, callback, type ) {
4914
		// shift arguments if data argument was omited
4915
		if ( jQuery.isFunction( data ) ) {
4916
			type = type || callback;
4917
			callback = data;
4918
			data = {};
4919
		}
4920
 
4921
		return jQuery.ajax({
4922
			type: "POST",
4923
			url: url,
4924
			data: data,
4925
			success: callback,
4926
			dataType: type
4927
		});
4928
	},
4929
 
4930
	ajaxSetup: function( settings ) {
4931
		jQuery.extend( jQuery.ajaxSettings, settings );
4932
	},
4933
 
4934
	ajaxSettings: {
4935
		url: location.href,
4936
		global: true,
4937
		type: "GET",
4938
		contentType: "application/x-www-form-urlencoded",
4939
		processData: true,
4940
		async: true,
4941
		/*
4942
		timeout: 0,
4943
		data: null,
4944
		username: null,
4945
		password: null,
4946
		traditional: false,
4947
		*/
4948
		// Create the request object; Microsoft failed to properly
4949
		// implement the XMLHttpRequest in IE7 (can't request local files),
4950
		// so we use the ActiveXObject when it is available
4951
		// This function can be overriden by calling jQuery.ajaxSetup
4952
		xhr: window.XMLHttpRequest && (window.location.protocol !== "file:" || !window.ActiveXObject) ?
4953
			function() {
4954
				return new window.XMLHttpRequest();
4955
			} :
4956
			function() {
4957
				try {
4958
					return new window.ActiveXObject("Microsoft.XMLHTTP");
4959
				} catch(e) {}
4960
			},
4961
		accepts: {
4962
			xml: "application/xml, text/xml",
4963
			html: "text/html",
4964
			script: "text/javascript, application/javascript",
4965
			json: "application/json, text/javascript",
4966
			text: "text/plain",
4967
			_default: "*/*"
4968
		}
4969
	},
4970
 
4971
	// Last-Modified header cache for next request
4972
	lastModified: {},
4973
	etag: {},
4974
 
4975
	ajax: function( origSettings ) {
4976
		var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings);
4977
 
4978
		var jsonp, status, data,
4979
			callbackContext = origSettings && origSettings.context || s,
4980
			type = s.type.toUpperCase();
4981
 
4982
		// convert data if not already a string
4983
		if ( s.data && s.processData && typeof s.data !== "string" ) {
4984
			s.data = jQuery.param( s.data, s.traditional );
4985
		}
4986
 
4987
		// Handle JSONP Parameter Callbacks
4988
		if ( s.dataType === "jsonp" ) {
4989
			if ( type === "GET" ) {
4990
				if ( !jsre.test( s.url ) ) {
4991
					s.url += (rquery.test( s.url ) ? "&" : "?") + (s.jsonp || "callback") + "=?";
4992
				}
4993
			} else if ( !s.data || !jsre.test(s.data) ) {
4994
				s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
4995
			}
4996
			s.dataType = "json";
4997
		}
4998
 
4999
		// Build temporary JSONP function
5000
		if ( s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url)) ) {
5001
			jsonp = s.jsonpCallback || ("jsonp" + jsc++);
5002
 
5003
			// Replace the =? sequence both in the query string and the data
5004
			if ( s.data ) {
5005
				s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
5006
			}
5007
 
5008
			s.url = s.url.replace(jsre, "=" + jsonp + "$1");
5009
 
5010
			// We need to make sure
5011
			// that a JSONP style response is executed properly
5012
			s.dataType = "script";
5013
 
5014
			// Handle JSONP-style loading
5015
			window[ jsonp ] = window[ jsonp ] || function( tmp ) {
5016
				data = tmp;
5017
				success();
5018
				complete();
5019
				// Garbage collect
5020
				window[ jsonp ] = undefined;
5021
 
5022
				try {
5023
					delete window[ jsonp ];
5024
				} catch(e) {}
5025
 
5026
				if ( head ) {
5027
					head.removeChild( script );
5028
				}
5029
			};
5030
		}
5031
 
5032
		if ( s.dataType === "script" && s.cache === null ) {
5033
			s.cache = false;
5034
		}
5035
 
5036
		if ( s.cache === false && type === "GET" ) {
5037
			var ts = now();
5038
 
5039
			// try replacing _= if it is there
5040
			var ret = s.url.replace(rts, "$1_=" + ts + "$2");
5041
 
5042
			// if nothing was replaced, add timestamp to the end
5043
			s.url = ret + ((ret === s.url) ? (rquery.test(s.url) ? "&" : "?") + "_=" + ts : "");
5044
		}
5045
 
5046
		// If data is available, append data to url for get requests
5047
		if ( s.data && type === "GET" ) {
5048
			s.url += (rquery.test(s.url) ? "&" : "?") + s.data;
5049
		}
5050
 
5051
		// Watch for a new set of requests
5052
		if ( s.global && ! jQuery.active++ ) {
5053
			jQuery.event.trigger( "ajaxStart" );
5054
		}
5055
 
5056
		// Matches an absolute URL, and saves the domain
5057
		var parts = rurl.exec( s.url ),
5058
			remote = parts && (parts[1] && parts[1] !== location.protocol || parts[2] !== location.host);
5059
 
5060
		// If we're requesting a remote document
5061
		// and trying to load JSON or Script with a GET
5062
		if ( s.dataType === "script" && type === "GET" && remote ) {
5063
			var head = document.getElementsByTagName("head")[0] || document.documentElement;
5064
			var script = document.createElement("script");
5065
			script.src = s.url;
5066
			if ( s.scriptCharset ) {
5067
				script.charset = s.scriptCharset;
5068
			}
5069
 
5070
			// Handle Script loading
5071
			if ( !jsonp ) {
5072
				var done = false;
5073
 
5074
				// Attach handlers for all browsers
5075
				script.onload = script.onreadystatechange = function() {
5076
					if ( !done && (!this.readyState ||
5077
							this.readyState === "loaded" || this.readyState === "complete") ) {
5078
						done = true;
5079
						success();
5080
						complete();
5081
 
5082
						// Handle memory leak in IE
5083
						script.onload = script.onreadystatechange = null;
5084
						if ( head && script.parentNode ) {
5085
							head.removeChild( script );
5086
						}
5087
					}
5088
				};
5089
			}
5090
 
5091
			// Use insertBefore instead of appendChild  to circumvent an IE6 bug.
5092
			// This arises when a base node is used (#2709 and #4378).
5093
			head.insertBefore( script, head.firstChild );
5094
 
5095
			// We handle everything using the script element injection
5096
			return undefined;
5097
		}
5098
 
5099
		var requestDone = false;
5100
 
5101
		// Create the request object
5102
		var xhr = s.xhr();
5103
 
5104
		if ( !xhr ) {
5105
			return;
5106
		}
5107
 
5108
		// Open the socket
5109
		// Passing null username, generates a login popup on Opera (#2865)
5110
		if ( s.username ) {
5111
			xhr.open(type, s.url, s.async, s.username, s.password);
5112
		} else {
5113
			xhr.open(type, s.url, s.async);
5114
		}
5115
 
5116
		// Need an extra try/catch for cross domain requests in Firefox 3
5117
		try {
5118
			// Set the correct header, if data is being sent
5119
			if ( s.data || origSettings && origSettings.contentType ) {
5120
				xhr.setRequestHeader("Content-Type", s.contentType);
5121
			}
5122
 
5123
			// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
5124
			if ( s.ifModified ) {
5125
				if ( jQuery.lastModified[s.url] ) {
5126
					xhr.setRequestHeader("If-Modified-Since", jQuery.lastModified[s.url]);
5127
				}
5128
 
5129
				if ( jQuery.etag[s.url] ) {
5130
					xhr.setRequestHeader("If-None-Match", jQuery.etag[s.url]);
5131
				}
5132
			}
5133
 
5134
			// Set header so the called script knows that it's an XMLHttpRequest
5135
			// Only send the header if it's not a remote XHR
5136
			if ( !remote ) {
5137
				xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
5138
			}
5139
 
5140
			// Set the Accepts header for the server, depending on the dataType
5141
			xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
5142
				s.accepts[ s.dataType ] + ", */*" :
5143
				s.accepts._default );
5144
		} catch(e) {}
5145
 
5146
		// Allow custom headers/mimetypes and early abort
5147
		if ( s.beforeSend && s.beforeSend.call(callbackContext, xhr, s) === false ) {
5148
			// Handle the global AJAX counter
5149
			if ( s.global && ! --jQuery.active ) {
5150
				jQuery.event.trigger( "ajaxStop" );
5151
			}
5152
 
5153
			// close opended socket
5154
			xhr.abort();
5155
			return false;
5156
		}
5157
 
5158
		if ( s.global ) {
5159
			trigger("ajaxSend", [xhr, s]);
5160
		}
5161
 
5162
		// Wait for a response to come back
5163
		var onreadystatechange = xhr.onreadystatechange = function( isTimeout ) {
5164
			// The request was aborted
5165
			if ( !xhr || xhr.readyState === 0 || isTimeout === "abort" ) {
5166
				// Opera doesn't call onreadystatechange before this point
5167
				// so we simulate the call
5168
				if ( !requestDone ) {
5169
					complete();
5170
				}
5171
 
5172
				requestDone = true;
5173
				if ( xhr ) {
5174
					xhr.onreadystatechange = jQuery.noop;
5175
				}
5176
 
5177
			// The transfer is complete and the data is available, or the request timed out
5178
			} else if ( !requestDone && xhr && (xhr.readyState === 4 || isTimeout === "timeout") ) {
5179
				requestDone = true;
5180
				xhr.onreadystatechange = jQuery.noop;
5181
 
5182
				status = isTimeout === "timeout" ?
5183
					"timeout" :
5184
					!jQuery.httpSuccess( xhr ) ?
5185
						"error" :
5186
						s.ifModified && jQuery.httpNotModified( xhr, s.url ) ?
5187
							"notmodified" :
5188
							"success";
5189
 
5190
				var errMsg;
5191
 
5192
				if ( status === "success" ) {
5193
					// Watch for, and catch, XML document parse errors
5194
					try {
5195
						// process the data (runs the xml through httpData regardless of callback)
5196
						data = jQuery.httpData( xhr, s.dataType, s );
5197
					} catch(err) {
5198
						status = "parsererror";
5199
						errMsg = err;
5200
					}
5201
				}
5202
 
5203
				// Make sure that the request was successful or notmodified
5204
				if ( status === "success" || status === "notmodified" ) {
5205
					// JSONP handles its own success callback
5206
					if ( !jsonp ) {
5207
						success();
5208
					}
5209
				} else {
5210
					jQuery.handleError(s, xhr, status, errMsg);
5211
				}
5212
 
5213
				// Fire the complete handlers
5214
				complete();
5215
 
5216
				if ( isTimeout === "timeout" ) {
5217
					xhr.abort();
5218
				}
5219
 
5220
				// Stop memory leaks
5221
				if ( s.async ) {
5222
					xhr = null;
5223
				}
5224
			}
5225
		};
5226
 
5227
		// Override the abort handler, if we can (IE doesn't allow it, but that's OK)
5228
		// Opera doesn't fire onreadystatechange at all on abort
5229
		try {
5230
			var oldAbort = xhr.abort;
5231
			xhr.abort = function() {
5232
				if ( xhr ) {
5233
					oldAbort.call( xhr );
5234
				}
5235
 
5236
				onreadystatechange( "abort" );
5237
			};
5238
		} catch(e) { }
5239
 
5240
		// Timeout checker
5241
		if ( s.async && s.timeout > 0 ) {
5242
			setTimeout(function() {
5243
				// Check to see if the request is still happening
5244
				if ( xhr && !requestDone ) {
5245
					onreadystatechange( "timeout" );
5246
				}
5247
			}, s.timeout);
5248
		}
5249
 
5250
		// Send the data
5251
		try {
5252
			xhr.send( type === "POST" || type === "PUT" || type === "DELETE" ? s.data : null );
5253
		} catch(e) {
5254
			jQuery.handleError(s, xhr, null, e);
5255
			// Fire the complete handlers
5256
			complete();
5257
		}
5258
 
5259
		// firefox 1.5 doesn't fire statechange for sync requests
5260
		if ( !s.async ) {
5261
			onreadystatechange();
5262
		}
5263
 
5264
		function success() {
5265
			// If a local callback was specified, fire it and pass it the data
5266
			if ( s.success ) {
5267
				s.success.call( callbackContext, data, status, xhr );
5268
			}
5269
 
5270
			// Fire the global callback
5271
			if ( s.global ) {
5272
				trigger( "ajaxSuccess", [xhr, s] );
5273
			}
5274
		}
5275
 
5276
		function complete() {
5277
			// Process result
5278
			if ( s.complete ) {
5279
				s.complete.call( callbackContext, xhr, status);
5280
			}
5281
 
5282
			// The request was completed
5283
			if ( s.global ) {
5284
				trigger( "ajaxComplete", [xhr, s] );
5285
			}
5286
 
5287
			// Handle the global AJAX counter
5288
			if ( s.global && ! --jQuery.active ) {
5289
				jQuery.event.trigger( "ajaxStop" );
5290
			}
5291
		}
5292
 
5293
		function trigger(type, args) {
5294
			(s.context ? jQuery(s.context) : jQuery.event).trigger(type, args);
5295
		}
5296
 
5297
		// return XMLHttpRequest to allow aborting the request etc.
5298
		return xhr;
5299
	},
5300
 
5301
	handleError: function( s, xhr, status, e ) {
5302
		// If a local callback was specified, fire it
5303
		if ( s.error ) {
5304
			s.error.call( s.context || s, xhr, status, e );
5305
		}
5306
 
5307
		// Fire the global callback
5308
		if ( s.global ) {
5309
			(s.context ? jQuery(s.context) : jQuery.event).trigger( "ajaxError", [xhr, s, e] );
5310
		}
5311
	},
5312
 
5313
	// Counter for holding the number of active queries
5314
	active: 0,
5315
 
5316
	// Determines if an XMLHttpRequest was successful or not
5317
	httpSuccess: function( xhr ) {
5318
		try {
5319
			// IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
5320
			return !xhr.status && location.protocol === "file:" ||
5321
				// Opera returns 0 when status is 304
5322
				( xhr.status >= 200 && xhr.status < 300 ) ||
5323
				xhr.status === 304 || xhr.status === 1223 || xhr.status === 0;
5324
		} catch(e) {}
5325
 
5326
		return false;
5327
	},
5328
 
5329
	// Determines if an XMLHttpRequest returns NotModified
5330
	httpNotModified: function( xhr, url ) {
5331
		var lastModified = xhr.getResponseHeader("Last-Modified"),
5332
			etag = xhr.getResponseHeader("Etag");
5333
 
5334
		if ( lastModified ) {
5335
			jQuery.lastModified[url] = lastModified;
5336
		}
5337
 
5338
		if ( etag ) {
5339
			jQuery.etag[url] = etag;
5340
		}
5341
 
5342
		// Opera returns 0 when status is 304
5343
		return xhr.status === 304 || xhr.status === 0;
5344
	},
5345
 
5346
	httpData: function( xhr, type, s ) {
5347
		var ct = xhr.getResponseHeader("content-type") || "",
5348
			xml = type === "xml" || !type && ct.indexOf("xml") >= 0,
5349
			data = xml ? xhr.responseXML : xhr.responseText;
5350
 
5351
		if ( xml && data.documentElement.nodeName === "parsererror" ) {
5352
			jQuery.error( "parsererror" );
5353
		}
5354
 
5355
		// Allow a pre-filtering function to sanitize the response
5356
		// s is checked to keep backwards compatibility
5357
		if ( s && s.dataFilter ) {
5358
			data = s.dataFilter( data, type );
5359
		}
5360
 
5361
		// The filter can actually parse the response
5362
		if ( typeof data === "string" ) {
5363
			// Get the JavaScript object, if JSON is used.
5364
			if ( type === "json" || !type && ct.indexOf("json") >= 0 ) {
5365
				data = jQuery.parseJSON( data );
5366
 
5367
			// If the type is "script", eval it in global context
5368
			} else if ( type === "script" || !type && ct.indexOf("javascript") >= 0 ) {
5369
				jQuery.globalEval( data );
5370
			}
5371
		}
5372
 
5373
		return data;
5374
	},
5375
 
5376
	// Serialize an array of form elements or a set of
5377
	// key/values into a query string
5378
	param: function( a, traditional ) {
5379
		var s = [];
5380
 
5381
		// Set traditional to true for jQuery <= 1.3.2 behavior.
5382
		if ( traditional === undefined ) {
5383
			traditional = jQuery.ajaxSettings.traditional;
5384
		}
5385
 
5386
		// If an array was passed in, assume that it is an array of form elements.
5387
		if ( jQuery.isArray(a) || a.jquery ) {
5388
			// Serialize the form elements
5389
			jQuery.each( a, function() {
5390
				add( this.name, this.value );
5391
			});
5392
 
5393
		} else {
5394
			// If traditional, encode the "old" way (the way 1.3.2 or older
5395
			// did it), otherwise encode params recursively.
5396
			for ( var prefix in a ) {
5397
				buildParams( prefix, a[prefix] );
5398
			}
5399
		}
5400
 
5401
		// Return the resulting serialization
5402
		return s.join("&").replace(r20, "+");
5403
 
5404
		function buildParams( prefix, obj ) {
5405
			if ( jQuery.isArray(obj) ) {
5406
				// Serialize array item.
5407
				jQuery.each( obj, function( i, v ) {
5408
					if ( traditional || /\[\]$/.test( prefix ) ) {
5409
						// Treat each array item as a scalar.
5410
						add( prefix, v );
5411
					} else {
5412
						// If array item is non-scalar (array or object), encode its
5413
						// numeric index to resolve deserialization ambiguity issues.
5414
						// Note that rack (as of 1.0.0) can't currently deserialize
5415
						// nested arrays properly, and attempting to do so may cause
5416
						// a server error. Possible fixes are to modify rack's
5417
						// deserialization algorithm or to provide an option or flag
5418
						// to force array serialization to be shallow.
5419
						buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v );
5420
					}
5421
				});
5422
 
5423
			} else if ( !traditional && obj != null && typeof obj === "object" ) {
5424
				// Serialize object item.
5425
				jQuery.each( obj, function( k, v ) {
5426
					buildParams( prefix + "[" + k + "]", v );
5427
				});
5428
 
5429
			} else {
5430
				// Serialize scalar item.
5431
				add( prefix, obj );
5432
			}
5433
		}
5434
 
5435
		function add( key, value ) {
5436
			// If value is a function, invoke it and return its value
5437
			value = jQuery.isFunction(value) ? value() : value;
5438
			s[ s.length ] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
5439
		}
5440
	}
5441
});
5442
var elemdisplay = {},
5443
	rfxtypes = /toggle|show|hide/,
5444
	rfxnum = /^([+-]=)?([\d+-.]+)(.*)$/,
5445
	timerId,
5446
	fxAttrs = [
5447
		// height animations
5448
		[ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
5449
		// width animations
5450
		[ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
5451
		// opacity animations
5452
		[ "opacity" ]
5453
	];
5454
 
5455
jQuery.fn.extend({
5456
	show: function( speed, callback ) {
5457
		if ( speed || speed === 0) {
5458
			return this.animate( genFx("show", 3), speed, callback);
5459
 
5460
		} else {
5461
			for ( var i = 0, l = this.length; i < l; i++ ) {
5462
				var old = jQuery.data(this[i], "olddisplay");
5463
 
5464
				this[i].style.display = old || "";
5465
 
5466
				if ( jQuery.css(this[i], "display") === "none" ) {
5467
					var nodeName = this[i].nodeName, display;
5468
 
5469
					if ( elemdisplay[ nodeName ] ) {
5470
						display = elemdisplay[ nodeName ];
5471
 
5472
					} else {
5473
						var elem = jQuery("<" + nodeName + " />").appendTo("body");
5474
 
5475
						display = elem.css("display");
5476
 
5477
						if ( display === "none" ) {
5478
							display = "block";
5479
						}
5480
 
5481
						elem.remove();
5482
 
5483
						elemdisplay[ nodeName ] = display;
5484
					}
5485
 
5486
					jQuery.data(this[i], "olddisplay", display);
5487
				}
5488
			}
5489
 
5490
			// Set the display of the elements in a second loop
5491
			// to avoid the constant reflow
5492
			for ( var j = 0, k = this.length; j < k; j++ ) {
5493
				this[j].style.display = jQuery.data(this[j], "olddisplay") || "";
5494
			}
5495
 
5496
			return this;
5497
		}
5498
	},
5499
 
5500
	hide: function( speed, callback ) {
5501
		if ( speed || speed === 0 ) {
5502
			return this.animate( genFx("hide", 3), speed, callback);
5503
 
5504
		} else {
5505
			for ( var i = 0, l = this.length; i < l; i++ ) {
5506
				var old = jQuery.data(this[i], "olddisplay");
5507
				if ( !old && old !== "none" ) {
5508
					jQuery.data(this[i], "olddisplay", jQuery.css(this[i], "display"));
5509
				}
5510
			}
5511
 
5512
			// Set the display of the elements in a second loop
5513
			// to avoid the constant reflow
5514
			for ( var j = 0, k = this.length; j < k; j++ ) {
5515
				this[j].style.display = "none";
5516
			}
5517
 
5518
			return this;
5519
		}
5520
	},
5521
 
5522
	// Save the old toggle function
5523
	_toggle: jQuery.fn.toggle,
5524
 
5525
	toggle: function( fn, fn2 ) {
5526
		var bool = typeof fn === "boolean";
5527
 
5528
		if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
5529
			this._toggle.apply( this, arguments );
5530
 
5531
		} else if ( fn == null || bool ) {
5532
			this.each(function() {
5533
				var state = bool ? fn : jQuery(this).is(":hidden");
5534
				jQuery(this)[ state ? "show" : "hide" ]();
5535
			});
5536
 
5537
		} else {
5538
			this.animate(genFx("toggle", 3), fn, fn2);
5539
		}
5540
 
5541
		return this;
5542
	},
5543
 
5544
	fadeTo: function( speed, to, callback ) {
5545
		return this.filter(":hidden").css("opacity", 0).show().end()
5546
					.animate({opacity: to}, speed, callback);
5547
	},
5548
 
5549
	animate: function( prop, speed, easing, callback ) {
5550
		var optall = jQuery.speed(speed, easing, callback);
5551
 
5552
		if ( jQuery.isEmptyObject( prop ) ) {
5553
			return this.each( optall.complete );
5554
		}
5555
 
5556
		return this[ optall.queue === false ? "each" : "queue" ](function() {
5557
			var opt = jQuery.extend({}, optall), p,
5558
				hidden = this.nodeType === 1 && jQuery(this).is(":hidden"),
5559
				self = this;
5560
 
5561
			for ( p in prop ) {
5562
				var name = p.replace(rdashAlpha, fcamelCase);
5563
 
5564
				if ( p !== name ) {
5565
					prop[ name ] = prop[ p ];
5566
					delete prop[ p ];
5567
					p = name;
5568
				}
5569
 
5570
				if ( prop[p] === "hide" && hidden || prop[p] === "show" && !hidden ) {
5571
					return opt.complete.call(this);
5572
				}
5573
 
5574
				if ( ( p === "height" || p === "width" ) && this.style ) {
5575
					// Store display property
5576
					opt.display = jQuery.css(this, "display");
5577
 
5578
					// Make sure that nothing sneaks out
5579
					opt.overflow = this.style.overflow;
5580
				}
5581
 
5582
				if ( jQuery.isArray( prop[p] ) ) {
5583
					// Create (if needed) and add to specialEasing
5584
					(opt.specialEasing = opt.specialEasing || {})[p] = prop[p][1];
5585
					prop[p] = prop[p][0];
5586
				}
5587
			}
5588
 
5589
			if ( opt.overflow != null ) {
5590
				this.style.overflow = "hidden";
5591
			}
5592
 
5593
			opt.curAnim = jQuery.extend({}, prop);
5594
 
5595
			jQuery.each( prop, function( name, val ) {
5596
				var e = new jQuery.fx( self, opt, name );
5597
 
5598
				if ( rfxtypes.test(val) ) {
5599
					e[ val === "toggle" ? hidden ? "show" : "hide" : val ]( prop );
5600
 
5601
				} else {
5602
					var parts = rfxnum.exec(val),
5603
						start = e.cur(true) || 0;
5604
 
5605
					if ( parts ) {
5606
						var end = parseFloat( parts[2] ),
5607
							unit = parts[3] || "px";
5608
 
5609
						// We need to compute starting value
5610
						if ( unit !== "px" ) {
5611
							self.style[ name ] = (end || 1) + unit;
5612
							start = ((end || 1) / e.cur(true)) * start;
5613
							self.style[ name ] = start + unit;
5614
						}
5615
 
5616
						// If a +=/-= token was provided, we're doing a relative animation
5617
						if ( parts[1] ) {
5618
							end = ((parts[1] === "-=" ? -1 : 1) * end) + start;
5619
						}
5620
 
5621
						e.custom( start, end, unit );
5622
 
5623
					} else {
5624
						e.custom( start, val, "" );
5625
					}
5626
				}
5627
			});
5628
 
5629
			// For JS strict compliance
5630
			return true;
5631
		});
5632
	},
5633
 
5634
	stop: function( clearQueue, gotoEnd ) {
5635
		var timers = jQuery.timers;
5636
 
5637
		if ( clearQueue ) {
5638
			this.queue([]);
5639
		}
5640
 
5641
		this.each(function() {
5642
			// go in reverse order so anything added to the queue during the loop is ignored
5643
			for ( var i = timers.length - 1; i >= 0; i-- ) {
5644
				if ( timers[i].elem === this ) {
5645
					if (gotoEnd) {
5646
						// force the next step to be the last
5647
						timers[i](true);
5648
					}
5649
 
5650
					timers.splice(i, 1);
5651
				}
5652
			}
5653
		});
5654
 
5655
		// start the next in the queue if the last step wasn't forced
5656
		if ( !gotoEnd ) {
5657
			this.dequeue();
5658
		}
5659
 
5660
		return this;
5661
	}
5662
 
5663
});
5664
 
5665
// Generate shortcuts for custom animations
5666
jQuery.each({
5667
	slideDown: genFx("show", 1),
5668
	slideUp: genFx("hide", 1),
5669
	slideToggle: genFx("toggle", 1),
5670
	fadeIn: { opacity: "show" },
5671
	fadeOut: { opacity: "hide" }
5672
}, function( name, props ) {
5673
	jQuery.fn[ name ] = function( speed, callback ) {
5674
		return this.animate( props, speed, callback );
5675
	};
5676
});
5677
 
5678
jQuery.extend({
5679
	speed: function( speed, easing, fn ) {
5680
		var opt = speed && typeof speed === "object" ? speed : {
5681
			complete: fn || !fn && easing ||
5682
				jQuery.isFunction( speed ) && speed,
5683
			duration: speed,
5684
			easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
5685
		};
5686
 
5687
		opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
5688
			jQuery.fx.speeds[opt.duration] || jQuery.fx.speeds._default;
5689
 
5690
		// Queueing
5691
		opt.old = opt.complete;
5692
		opt.complete = function() {
5693
			if ( opt.queue !== false ) {
5694
				jQuery(this).dequeue();
5695
			}
5696
			if ( jQuery.isFunction( opt.old ) ) {
5697
				opt.old.call( this );
5698
			}
5699
		};
5700
 
5701
		return opt;
5702
	},
5703
 
5704
	easing: {
5705
		linear: function( p, n, firstNum, diff ) {
5706
			return firstNum + diff * p;
5707
		},
5708
		swing: function( p, n, firstNum, diff ) {
5709
			return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
5710
		}
5711
	},
5712
 
5713
	timers: [],
5714
 
5715
	fx: function( elem, options, prop ) {
5716
		this.options = options;
5717
		this.elem = elem;
5718
		this.prop = prop;
5719
 
5720
		if ( !options.orig ) {
5721
			options.orig = {};
5722
		}
5723
	}
5724
 
5725
});
5726
 
5727
jQuery.fx.prototype = {
5728
	// Simple function for setting a style value
5729
	update: function() {
5730
		if ( this.options.step ) {
5731
			this.options.step.call( this.elem, this.now, this );
5732
		}
5733
 
5734
		(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
5735
 
5736
		// Set display property to block for height/width animations
5737
		if ( ( this.prop === "height" || this.prop === "width" ) && this.elem.style ) {
5738
			this.elem.style.display = "block";
5739
		}
5740
	},
5741
 
5742
	// Get the current size
5743
	cur: function( force ) {
5744
		if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
5745
			return this.elem[ this.prop ];
5746
		}
5747
 
5748
		var r = parseFloat(jQuery.css(this.elem, this.prop, force));
5749
		return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
5750
	},
5751
 
5752
	// Start an animation from one number to another
5753
	custom: function( from, to, unit ) {
5754
		this.startTime = now();
5755
		this.start = from;
5756
		this.end = to;
5757
		this.unit = unit || this.unit || "px";
5758
		this.now = this.start;
5759
		this.pos = this.state = 0;
5760
 
5761
		var self = this;
5762
		function t( gotoEnd ) {
5763
			return self.step(gotoEnd);
5764
		}
5765
 
5766
		t.elem = this.elem;
5767
 
5768
		if ( t() && jQuery.timers.push(t) && !timerId ) {
5769
			timerId = setInterval(jQuery.fx.tick, 13);
5770
		}
5771
	},
5772
 
5773
	// Simple 'show' function
5774
	show: function() {
5775
		// Remember where we started, so that we can go back to it later
5776
		this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
5777
		this.options.show = true;
5778
 
5779
		// Begin the animation
5780
		// Make sure that we start at a small width/height to avoid any
5781
		// flash of content
5782
		this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
5783
 
5784
		// Start by showing the element
5785
		jQuery( this.elem ).show();
5786
	},
5787
 
5788
	// Simple 'hide' function
5789
	hide: function() {
5790
		// Remember where we started, so that we can go back to it later
5791
		this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
5792
		this.options.hide = true;
5793
 
5794
		// Begin the animation
5795
		this.custom(this.cur(), 0);
5796
	},
5797
 
5798
	// Each step of an animation
5799
	step: function( gotoEnd ) {
5800
		var t = now(), done = true;
5801
 
5802
		if ( gotoEnd || t >= this.options.duration + this.startTime ) {
5803
			this.now = this.end;
5804
			this.pos = this.state = 1;
5805
			this.update();
5806
 
5807
			this.options.curAnim[ this.prop ] = true;
5808
 
5809
			for ( var i in this.options.curAnim ) {
5810
				if ( this.options.curAnim[i] !== true ) {
5811
					done = false;
5812
				}
5813
			}
5814
 
5815
			if ( done ) {
5816
				if ( this.options.display != null ) {
5817
					// Reset the overflow
5818
					this.elem.style.overflow = this.options.overflow;
5819
 
5820
					// Reset the display
5821
					var old = jQuery.data(this.elem, "olddisplay");
5822
					this.elem.style.display = old ? old : this.options.display;
5823
 
5824
					if ( jQuery.css(this.elem, "display") === "none" ) {
5825
						this.elem.style.display = "block";
5826
					}
5827
				}
5828
 
5829
				// Hide the element if the "hide" operation was done
5830
				if ( this.options.hide ) {
5831
					jQuery(this.elem).hide();
5832
				}
5833
 
5834
				// Reset the properties, if the item has been hidden or shown
5835
				if ( this.options.hide || this.options.show ) {
5836
					for ( var p in this.options.curAnim ) {
5837
						jQuery.style(this.elem, p, this.options.orig[p]);
5838
					}
5839
				}
5840
 
5841
				// Execute the complete function
5842
				this.options.complete.call( this.elem );
5843
			}
5844
 
5845
			return false;
5846
 
5847
		} else {
5848
			var n = t - this.startTime;
5849
			this.state = n / this.options.duration;
5850
 
5851
			// Perform the easing function, defaults to swing
5852
			var specialEasing = this.options.specialEasing && this.options.specialEasing[this.prop];
5853
			var defaultEasing = this.options.easing || (jQuery.easing.swing ? "swing" : "linear");
5854
			this.pos = jQuery.easing[specialEasing || defaultEasing](this.state, n, 0, 1, this.options.duration);
5855
			this.now = this.start + ((this.end - this.start) * this.pos);
5856
 
5857
			// Perform the next step of the animation
5858
			this.update();
5859
		}
5860
 
5861
		return true;
5862
	}
5863
};
5864
 
5865
jQuery.extend( jQuery.fx, {
5866
	tick: function() {
5867
		var timers = jQuery.timers;
5868
 
5869
		for ( var i = 0; i < timers.length; i++ ) {
5870
			if ( !timers[i]() ) {
5871
				timers.splice(i--, 1);
5872
			}
5873
		}
5874
 
5875
		if ( !timers.length ) {
5876
			jQuery.fx.stop();
5877
		}
5878
	},
5879
 
5880
	stop: function() {
5881
		clearInterval( timerId );
5882
		timerId = null;
5883
	},
5884
 
5885
	speeds: {
5886
		slow: 600,
5887
 		fast: 200,
5888
 		// Default speed
5889
 		_default: 400
5890
	},
5891
 
5892
	step: {
5893
		opacity: function( fx ) {
5894
			jQuery.style(fx.elem, "opacity", fx.now);
5895
		},
5896
 
5897
		_default: function( fx ) {
5898
			if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
5899
				fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
5900
			} else {
5901
				fx.elem[ fx.prop ] = fx.now;
5902
			}
5903
		}
5904
	}
5905
});
5906
 
5907
if ( jQuery.expr && jQuery.expr.filters ) {
5908
	jQuery.expr.filters.animated = function( elem ) {
5909
		return jQuery.grep(jQuery.timers, function( fn ) {
5910
			return elem === fn.elem;
5911
		}).length;
5912
	};
5913
}
5914
 
5915
function genFx( type, num ) {
5916
	var obj = {};
5917
 
5918
	jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
5919
		obj[ this ] = type;
5920
	});
5921
 
5922
	return obj;
5923
}
5924
if ( "getBoundingClientRect" in document.documentElement ) {
5925
	jQuery.fn.offset = function( options ) {
5926
		var elem = this[0];
5927
 
5928
		if ( options ) {
5929
			return this.each(function( i ) {
5930
				jQuery.offset.setOffset( this, options, i );
5931
			});
5932
		}
5933
 
5934
		if ( !elem || !elem.ownerDocument ) {
5935
			return null;
5936
		}
5937
 
5938
		if ( elem === elem.ownerDocument.body ) {
5939
			return jQuery.offset.bodyOffset( elem );
5940
		}
5941
 
5942
		var box = elem.getBoundingClientRect(), doc = elem.ownerDocument, body = doc.body, docElem = doc.documentElement,
5943
			clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0,
5944
			top  = box.top  + (self.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop ) - clientTop,
5945
			left = box.left + (self.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft) - clientLeft;
5946
 
5947
		return { top: top, left: left };
5948
	};
5949
 
5950
} else {
5951
	jQuery.fn.offset = function( options ) {
5952
		var elem = this[0];
5953
 
5954
		if ( options ) {
5955
			return this.each(function( i ) {
5956
				jQuery.offset.setOffset( this, options, i );
5957
			});
5958
		}
5959
 
5960
		if ( !elem || !elem.ownerDocument ) {
5961
			return null;
5962
		}
5963
 
5964
		if ( elem === elem.ownerDocument.body ) {
5965
			return jQuery.offset.bodyOffset( elem );
5966
		}
5967
 
5968
		jQuery.offset.initialize();
5969
 
5970
		var offsetParent = elem.offsetParent, prevOffsetParent = elem,
5971
			doc = elem.ownerDocument, computedStyle, docElem = doc.documentElement,
5972
			body = doc.body, defaultView = doc.defaultView,
5973
			prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
5974
			top = elem.offsetTop, left = elem.offsetLeft;
5975
 
5976
		while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
5977
			if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
5978
				break;
5979
			}
5980
 
5981
			computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
5982
			top  -= elem.scrollTop;
5983
			left -= elem.scrollLeft;
5984
 
5985
			if ( elem === offsetParent ) {
5986
				top  += elem.offsetTop;
5987
				left += elem.offsetLeft;
5988
 
5989
				if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.nodeName)) ) {
5990
					top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
5991
					left += parseFloat( computedStyle.borderLeftWidth ) || 0;
5992
				}
5993
 
5994
				prevOffsetParent = offsetParent, offsetParent = elem.offsetParent;
5995
			}
5996
 
5997
			if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
5998
				top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
5999
				left += parseFloat( computedStyle.borderLeftWidth ) || 0;
6000
			}
6001
 
6002
			prevComputedStyle = computedStyle;
6003
		}
6004
 
6005
		if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
6006
			top  += body.offsetTop;
6007
			left += body.offsetLeft;
6008
		}
6009
 
6010
		if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
6011
			top  += Math.max( docElem.scrollTop, body.scrollTop );
6012
			left += Math.max( docElem.scrollLeft, body.scrollLeft );
6013
		}
6014
 
6015
		return { top: top, left: left };
6016
	};
6017
}
6018
 
6019
jQuery.offset = {
6020
	initialize: function() {
6021
		var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.curCSS(body, "marginTop", true) ) || 0,
6022
			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>";
6023
 
6024
		jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
6025
 
6026
		container.innerHTML = html;
6027
		body.insertBefore( container, body.firstChild );
6028
		innerDiv = container.firstChild;
6029
		checkDiv = innerDiv.firstChild;
6030
		td = innerDiv.nextSibling.firstChild.firstChild;
6031
 
6032
		this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
6033
		this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
6034
 
6035
		checkDiv.style.position = "fixed", checkDiv.style.top = "20px";
6036
		// safari subtracts parent border width here which is 5px
6037
		this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
6038
		checkDiv.style.position = checkDiv.style.top = "";
6039
 
6040
		innerDiv.style.overflow = "hidden", innerDiv.style.position = "relative";
6041
		this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
6042
 
6043
		this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
6044
 
6045
		body.removeChild( container );
6046
		body = container = innerDiv = checkDiv = table = td = null;
6047
		jQuery.offset.initialize = jQuery.noop;
6048
	},
6049
 
6050
	bodyOffset: function( body ) {
6051
		var top = body.offsetTop, left = body.offsetLeft;
6052
 
6053
		jQuery.offset.initialize();
6054
 
6055
		if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
6056
			top  += parseFloat( jQuery.curCSS(body, "marginTop",  true) ) || 0;
6057
			left += parseFloat( jQuery.curCSS(body, "marginLeft", true) ) || 0;
6058
		}
6059
 
6060
		return { top: top, left: left };
6061
	},
6062
 
6063
	setOffset: function( elem, options, i ) {
6064
		// set position first, in-case top/left are set even on static elem
6065
		if ( /static/.test( jQuery.curCSS( elem, "position" ) ) ) {
6066
			elem.style.position = "relative";
6067
		}
6068
		var curElem   = jQuery( elem ),
6069
			curOffset = curElem.offset(),
6070
			curTop    = parseInt( jQuery.curCSS( elem, "top",  true ), 10 ) || 0,
6071
			curLeft   = parseInt( jQuery.curCSS( elem, "left", true ), 10 ) || 0;
6072
 
6073
		if ( jQuery.isFunction( options ) ) {
6074
			options = options.call( elem, i, curOffset );
6075
		}
6076
 
6077
		var props = {
6078
			top:  (options.top  - curOffset.top)  + curTop,
6079
			left: (options.left - curOffset.left) + curLeft
6080
		};
6081
 
6082
		if ( "using" in options ) {
6083
			options.using.call( elem, props );
6084
		} else {
6085
			curElem.css( props );
6086
		}
6087
	}
6088
};
6089
 
6090
 
6091
jQuery.fn.extend({
6092
	position: function() {
6093
		if ( !this[0] ) {
6094
			return null;
6095
		}
6096
 
6097
		var elem = this[0],
6098
 
6099
		// Get *real* offsetParent
6100
		offsetParent = this.offsetParent(),
6101
 
6102
		// Get correct offsets
6103
		offset       = this.offset(),
6104
		parentOffset = /^body|html$/i.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
6105
 
6106
		// Subtract element margins
6107
		// note: when an element has margin: auto the offsetLeft and marginLeft
6108
		// are the same in Safari causing offset.left to incorrectly be 0
6109
		offset.top  -= parseFloat( jQuery.curCSS(elem, "marginTop",  true) ) || 0;
6110
		offset.left -= parseFloat( jQuery.curCSS(elem, "marginLeft", true) ) || 0;
6111
 
6112
		// Add offsetParent borders
6113
		parentOffset.top  += parseFloat( jQuery.curCSS(offsetParent[0], "borderTopWidth",  true) ) || 0;
6114
		parentOffset.left += parseFloat( jQuery.curCSS(offsetParent[0], "borderLeftWidth", true) ) || 0;
6115
 
6116
		// Subtract the two offsets
6117
		return {
6118
			top:  offset.top  - parentOffset.top,
6119
			left: offset.left - parentOffset.left
6120
		};
6121
	},
6122
 
6123
	offsetParent: function() {
6124
		return this.map(function() {
6125
			var offsetParent = this.offsetParent || document.body;
6126
			while ( offsetParent && (!/^body|html$/i.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
6127
				offsetParent = offsetParent.offsetParent;
6128
			}
6129
			return offsetParent;
6130
		});
6131
	}
6132
});
6133
 
6134
 
6135
// Create scrollLeft and scrollTop methods
6136
jQuery.each( ["Left", "Top"], function( i, name ) {
6137
	var method = "scroll" + name;
6138
 
6139
	jQuery.fn[ method ] = function(val) {
6140
		var elem = this[0], win;
6141
 
6142
		if ( !elem ) {
6143
			return null;
6144
		}
6145
 
6146
		if ( val !== undefined ) {
6147
			// Set the scroll offset
6148
			return this.each(function() {
6149
				win = getWindow( this );
6150
 
6151
				if ( win ) {
6152
					win.scrollTo(
6153
						!i ? val : jQuery(win).scrollLeft(),
6154
						 i ? val : jQuery(win).scrollTop()
6155
					);
6156
 
6157
				} else {
6158
					this[ method ] = val;
6159
				}
6160
			});
6161
		} else {
6162
			win = getWindow( elem );
6163
 
6164
			// Return the scroll offset
6165
			return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
6166
				jQuery.support.boxModel && win.document.documentElement[ method ] ||
6167
					win.document.body[ method ] :
6168
				elem[ method ];
6169
		}
6170
	};
6171
});
6172
 
6173
function getWindow( elem ) {
6174
	return ("scrollTo" in elem && elem.document) ?
6175
		elem :
6176
		elem.nodeType === 9 ?
6177
			elem.defaultView || elem.parentWindow :
6178
			false;
6179
}
6180
// Create innerHeight, innerWidth, outerHeight and outerWidth methods
6181
jQuery.each([ "Height", "Width" ], function( i, name ) {
6182
 
6183
	var type = name.toLowerCase();
6184
 
6185
	// innerHeight and innerWidth
6186
	jQuery.fn["inner" + name] = function() {
6187
		return this[0] ?
6188
			jQuery.css( this[0], type, false, "padding" ) :
6189
			null;
6190
	};
6191
 
6192
	// outerHeight and outerWidth
6193
	jQuery.fn["outer" + name] = function( margin ) {
6194
		return this[0] ?
6195
			jQuery.css( this[0], type, false, margin ? "margin" : "border" ) :
6196
			null;
6197
	};
6198
 
6199
	jQuery.fn[ type ] = function( size ) {
6200
		// Get window width or height
6201
		var elem = this[0];
6202
		if ( !elem ) {
6203
			return size == null ? null : this;
6204
		}
6205
 
6206
		if ( jQuery.isFunction( size ) ) {
6207
			return this.each(function( i ) {
6208
				var self = jQuery( this );
6209
				self[ type ]( size.call( this, i, self[ type ]() ) );
6210
			});
6211
		}
6212
 
6213
		return ("scrollTo" in elem && elem.document) ? // does it walk and quack like a window?
6214
			// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
6215
			elem.document.compatMode === "CSS1Compat" && elem.document.documentElement[ "client" + name ] ||
6216
			elem.document.body[ "client" + name ] :
6217
 
6218
			// Get document width or height
6219
			(elem.nodeType === 9) ? // is it a document
6220
				// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
6221
				Math.max(
6222
					elem.documentElement["client" + name],
6223
					elem.body["scroll" + name], elem.documentElement["scroll" + name],
6224
					elem.body["offset" + name], elem.documentElement["offset" + name]
6225
				) :
6226
 
6227
				// Get or set width or height on the element
6228
				size === undefined ?
6229
					// Get width or height on the element
6230
					jQuery.css( elem, type ) :
6231
 
6232
					// Set the width or height on the element (default to pixels if value is unitless)
6233
					this.css( type, typeof size === "string" ? size : size + "px" );
6234
	};
6235
 
6236
});
6237
// Expose jQuery to the global object
6238
window.jQuery = window.$ = jQuery;
6239
 
6240
})(window);