Subversion Repositories Sites.obs-saisons.fr

Rev

Rev 31 | Details | Compare with Previous | Last modification | View Log | RSS feed

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