Revision 18059f42

/dev/null
1
/*!
2
 * jQuery JavaScript Library v1.7.1
3
 * http://jquery.com/
4
 *
5
 * Copyright 2011, John Resig
6
 * Dual licensed under the MIT or GPL Version 2 licenses.
7
 * http://jquery.org/license
8
 *
9
 * Includes Sizzle.js
10
 * http://sizzlejs.com/
11
 * Copyright 2011, The Dojo Foundation
12
 * Released under the MIT, BSD, and GPL Licenses.
13
 *
14
 * Date: Mon Nov 21 21:11:03 2011 -0500
15
 */
16
(function( window, undefined ) {
17

  
18
// Use the correct document accordingly with window argument (sandbox)
19
var document = window.document,
20
	navigator = window.navigator,
21
	location = window.location;
22
var jQuery = (function() {
23

  
24
// Define a local copy of jQuery
25
var jQuery = function( selector, context ) {
26
		// The jQuery object is actually just the init constructor 'enhanced'
27
		return new jQuery.fn.init( selector, context, rootjQuery );
28
	},
29

  
30
	// Map over jQuery in case of overwrite
31
	_jQuery = window.jQuery,
32

  
33
	// Map over the $ in case of overwrite
34
	_$ = window.$,
35

  
36
	// A central reference to the root jQuery(document)
37
	rootjQuery,
38

  
39
	// A simple way to check for HTML strings or ID strings
40
	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
41
	quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
42

  
43
	// Check if a string has a non-whitespace character in it
44
	rnotwhite = /\S/,
45

  
46
	// Used for trimming whitespace
47
	trimLeft = /^\s+/,
48
	trimRight = /\s+$/,
49

  
50
	// Match a standalone tag
51
	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
52

  
53
	// JSON RegExp
54
	rvalidchars = /^[\],:{}\s]*$/,
55
	rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
56
	rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
57
	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
58

  
59
	// Useragent RegExp
60
	rwebkit = /(webkit)[ \/]([\w.]+)/,
61
	ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
62
	rmsie = /(msie) ([\w.]+)/,
63
	rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
64

  
65
	// Matches dashed string for camelizing
66
	rdashAlpha = /-([a-z]|[0-9])/ig,
67
	rmsPrefix = /^-ms-/,
68

  
69
	// Used by jQuery.camelCase as callback to replace()
70
	fcamelCase = function( all, letter ) {
71
		return ( letter + "" ).toUpperCase();
72
	},
73

  
74
	// Keep a UserAgent string for use with jQuery.browser
75
	userAgent = navigator.userAgent,
76

  
77
	// For matching the engine and version of the browser
78
	browserMatch,
79

  
80
	// The deferred used on DOM ready
81
	readyList,
82

  
83
	// The ready event handler
84
	DOMContentLoaded,
85

  
86
	// Save a reference to some core methods
87
	toString = Object.prototype.toString,
88
	hasOwn = Object.prototype.hasOwnProperty,
89
	push = Array.prototype.push,
90
	slice = Array.prototype.slice,
91
	trim = String.prototype.trim,
92
	indexOf = Array.prototype.indexOf,
93

  
94
	// [[Class]] -> type pairs
95
	class2type = {};
96

  
97
jQuery.fn = jQuery.prototype = {
98
	constructor: jQuery,
99
	init: function( selector, context, rootjQuery ) {
100
		var match, elem, ret, doc;
101

  
102
		// Handle $(""), $(null), or $(undefined)
103
		if ( !selector ) {
104
			return this;
105
		}
106

  
107
		// Handle $(DOMElement)
108
		if ( selector.nodeType ) {
109
			this.context = this[0] = selector;
110
			this.length = 1;
111
			return this;
112
		}
113

  
114
		// The body element only exists once, optimize finding it
115
		if ( selector === "body" && !context && document.body ) {
116
			this.context = document;
117
			this[0] = document.body;
118
			this.selector = selector;
119
			this.length = 1;
120
			return this;
121
		}
122

  
123
		// Handle HTML strings
124
		if ( typeof selector === "string" ) {
125
			// Are we dealing with HTML string or an ID?
126
			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
127
				// Assume that strings that start and end with <> are HTML and skip the regex check
128
				match = [ null, selector, null ];
129

  
130
			} else {
131
				match = quickExpr.exec( selector );
132
			}
133

  
134
			// Verify a match, and that no context was specified for #id
135
			if ( match && (match[1] || !context) ) {
136

  
137
				// HANDLE: $(html) -> $(array)
138
				if ( match[1] ) {
139
					context = context instanceof jQuery ? context[0] : context;
140
					doc = ( context ? context.ownerDocument || context : document );
141

  
142
					// If a single string is passed in and it's a single tag
143
					// just do a createElement and skip the rest
144
					ret = rsingleTag.exec( selector );
145

  
146
					if ( ret ) {
147
						if ( jQuery.isPlainObject( context ) ) {
148
							selector = [ document.createElement( ret[1] ) ];
149
							jQuery.fn.attr.call( selector, context, true );
150

  
151
						} else {
152
							selector = [ doc.createElement( ret[1] ) ];
153
						}
154

  
155
					} else {
156
						ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
157
						selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes;
158
					}
159

  
160
					return jQuery.merge( this, selector );
161

  
162
				// HANDLE: $("#id")
163
				} else {
164
					elem = document.getElementById( match[2] );
165

  
166
					// Check parentNode to catch when Blackberry 4.6 returns
167
					// nodes that are no longer in the document #6963
168
					if ( elem && elem.parentNode ) {
169
						// Handle the case where IE and Opera return items
170
						// by name instead of ID
171
						if ( elem.id !== match[2] ) {
172
							return rootjQuery.find( selector );
173
						}
174

  
175
						// Otherwise, we inject the element directly into the jQuery object
176
						this.length = 1;
177
						this[0] = elem;
178
					}
179

  
180
					this.context = document;
181
					this.selector = selector;
182
					return this;
183
				}
184

  
185
			// HANDLE: $(expr, $(...))
186
			} else if ( !context || context.jquery ) {
187
				return ( context || rootjQuery ).find( selector );
188

  
189
			// HANDLE: $(expr, context)
190
			// (which is just equivalent to: $(context).find(expr)
191
			} else {
192
				return this.constructor( context ).find( selector );
193
			}
194

  
195
		// HANDLE: $(function)
196
		// Shortcut for document ready
197
		} else if ( jQuery.isFunction( selector ) ) {
198
			return rootjQuery.ready( selector );
199
		}
200

  
201
		if ( selector.selector !== undefined ) {
202
			this.selector = selector.selector;
203
			this.context = selector.context;
204
		}
205

  
206
		return jQuery.makeArray( selector, this );
207
	},
208

  
209
	// Start with an empty selector
210
	selector: "",
211

  
212
	// The current version of jQuery being used
213
	jquery: "1.7.1",
214

  
215
	// The default length of a jQuery object is 0
216
	length: 0,
217

  
218
	// The number of elements contained in the matched element set
219
	size: function() {
220
		return this.length;
221
	},
222

  
223
	toArray: function() {
224
		return slice.call( this, 0 );
225
	},
226

  
227
	// Get the Nth element in the matched element set OR
228
	// Get the whole matched element set as a clean array
229
	get: function( num ) {
230
		return num == null ?
231

  
232
			// Return a 'clean' array
233
			this.toArray() :
234

  
235
			// Return just the object
236
			( num < 0 ? this[ this.length + num ] : this[ num ] );
237
	},
238

  
239
	// Take an array of elements and push it onto the stack
240
	// (returning the new matched element set)
241
	pushStack: function( elems, name, selector ) {
242
		// Build a new jQuery matched element set
243
		var ret = this.constructor();
244

  
245
		if ( jQuery.isArray( elems ) ) {
246
			push.apply( ret, elems );
247

  
248
		} else {
249
			jQuery.merge( ret, elems );
250
		}
251

  
252
		// Add the old object onto the stack (as a reference)
253
		ret.prevObject = this;
254

  
255
		ret.context = this.context;
256

  
257
		if ( name === "find" ) {
258
			ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
259
		} else if ( name ) {
260
			ret.selector = this.selector + "." + name + "(" + selector + ")";
261
		}
262

  
263
		// Return the newly-formed element set
264
		return ret;
265
	},
266

  
267
	// Execute a callback for every element in the matched set.
268
	// (You can seed the arguments with an array of args, but this is
269
	// only used internally.)
270
	each: function( callback, args ) {
271
		return jQuery.each( this, callback, args );
272
	},
273

  
274
	ready: function( fn ) {
275
		// Attach the listeners
276
		jQuery.bindReady();
277

  
278
		// Add the callback
279
		readyList.add( fn );
280

  
281
		return this;
282
	},
283

  
284
	eq: function( i ) {
285
		i = +i;
286
		return i === -1 ?
287
			this.slice( i ) :
288
			this.slice( i, i + 1 );
289
	},
290

  
291
	first: function() {
292
		return this.eq( 0 );
293
	},
294

  
295
	last: function() {
296
		return this.eq( -1 );
297
	},
298

  
299
	slice: function() {
300
		return this.pushStack( slice.apply( this, arguments ),
301
			"slice", slice.call(arguments).join(",") );
302
	},
303

  
304
	map: function( callback ) {
305
		return this.pushStack( jQuery.map(this, function( elem, i ) {
306
			return callback.call( elem, i, elem );
307
		}));
308
	},
309

  
310
	end: function() {
311
		return this.prevObject || this.constructor(null);
312
	},
313

  
314
	// For internal use only.
315
	// Behaves like an Array's method, not like a jQuery method.
316
	push: push,
317
	sort: [].sort,
318
	splice: [].splice
319
};
320

  
321
// Give the init function the jQuery prototype for later instantiation
322
jQuery.fn.init.prototype = jQuery.fn;
323

  
324
jQuery.extend = jQuery.fn.extend = function() {
325
	var options, name, src, copy, copyIsArray, clone,
326
		target = arguments[0] || {},
327
		i = 1,
328
		length = arguments.length,
329
		deep = false;
330

  
331
	// Handle a deep copy situation
332
	if ( typeof target === "boolean" ) {
333
		deep = target;
334
		target = arguments[1] || {};
335
		// skip the boolean and the target
336
		i = 2;
337
	}
338

  
339
	// Handle case when target is a string or something (possible in deep copy)
340
	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
341
		target = {};
342
	}
343

  
344
	// extend jQuery itself if only one argument is passed
345
	if ( length === i ) {
346
		target = this;
347
		--i;
348
	}
349

  
350
	for ( ; i < length; i++ ) {
351
		// Only deal with non-null/undefined values
352
		if ( (options = arguments[ i ]) != null ) {
353
			// Extend the base object
354
			for ( name in options ) {
355
				src = target[ name ];
356
				copy = options[ name ];
357

  
358
				// Prevent never-ending loop
359
				if ( target === copy ) {
360
					continue;
361
				}
362

  
363
				// Recurse if we're merging plain objects or arrays
364
				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
365
					if ( copyIsArray ) {
366
						copyIsArray = false;
367
						clone = src && jQuery.isArray(src) ? src : [];
368

  
369
					} else {
370
						clone = src && jQuery.isPlainObject(src) ? src : {};
371
					}
372

  
373
					// Never move original objects, clone them
374
					target[ name ] = jQuery.extend( deep, clone, copy );
375

  
376
				// Don't bring in undefined values
377
				} else if ( copy !== undefined ) {
378
					target[ name ] = copy;
379
				}
380
			}
381
		}
382
	}
383

  
384
	// Return the modified object
385
	return target;
386
};
387

  
388
jQuery.extend({
389
	noConflict: function( deep ) {
390
		if ( window.$ === jQuery ) {
391
			window.$ = _$;
392
		}
393

  
394
		if ( deep && window.jQuery === jQuery ) {
395
			window.jQuery = _jQuery;
396
		}
397

  
398
		return jQuery;
399
	},
400

  
401
	// Is the DOM ready to be used? Set to true once it occurs.
402
	isReady: false,
403

  
404
	// A counter to track how many items to wait for before
405
	// the ready event fires. See #6781
406
	readyWait: 1,
407

  
408
	// Hold (or release) the ready event
409
	holdReady: function( hold ) {
410
		if ( hold ) {
411
			jQuery.readyWait++;
412
		} else {
413
			jQuery.ready( true );
414
		}
415
	},
416

  
417
	// Handle when the DOM is ready
418
	ready: function( wait ) {
419
		// Either a released hold or an DOMready/load event and not yet ready
420
		if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
421
			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
422
			if ( !document.body ) {
423
				return setTimeout( jQuery.ready, 1 );
424
			}
425

  
426
			// Remember that the DOM is ready
427
			jQuery.isReady = true;
428

  
429
			// If a normal DOM Ready event fired, decrement, and wait if need be
430
			if ( wait !== true && --jQuery.readyWait > 0 ) {
431
				return;
432
			}
433

  
434
			// If there are functions bound, to execute
435
			readyList.fireWith( document, [ jQuery ] );
436

  
437
			// Trigger any bound ready events
438
			if ( jQuery.fn.trigger ) {
439
				jQuery( document ).trigger( "ready" ).off( "ready" );
440
			}
441
		}
442
	},
443

  
444
	bindReady: function() {
445
		if ( readyList ) {
446
			return;
447
		}
448

  
449
		readyList = jQuery.Callbacks( "once memory" );
450

  
451
		// Catch cases where $(document).ready() is called after the
452
		// browser event has already occurred.
453
		if ( document.readyState === "complete" ) {
454
			// Handle it asynchronously to allow scripts the opportunity to delay ready
455
			return setTimeout( jQuery.ready, 1 );
456
		}
457

  
458
		// Mozilla, Opera and webkit nightlies currently support this event
459
		if ( document.addEventListener ) {
460
			// Use the handy event callback
461
			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
462

  
463
			// A fallback to window.onload, that will always work
464
			window.addEventListener( "load", jQuery.ready, false );
465

  
466
		// If IE event model is used
467
		} else if ( document.attachEvent ) {
468
			// ensure firing before onload,
469
			// maybe late but safe also for iframes
470
			document.attachEvent( "onreadystatechange", DOMContentLoaded );
471

  
472
			// A fallback to window.onload, that will always work
473
			window.attachEvent( "onload", jQuery.ready );
474

  
475
			// If IE and not a frame
476
			// continually check to see if the document is ready
477
			var toplevel = false;
478

  
479
			try {
480
				toplevel = window.frameElement == null;
481
			} catch(e) {}
482

  
483
			if ( document.documentElement.doScroll && toplevel ) {
484
				doScrollCheck();
485
			}
486
		}
487
	},
488

  
489
	// See test/unit/core.js for details concerning isFunction.
490
	// Since version 1.3, DOM methods and functions like alert
491
	// aren't supported. They return false on IE (#2968).
492
	isFunction: function( obj ) {
493
		return jQuery.type(obj) === "function";
494
	},
495

  
496
	isArray: Array.isArray || function( obj ) {
497
		return jQuery.type(obj) === "array";
498
	},
499

  
500
	// A crude way of determining if an object is a window
501
	isWindow: function( obj ) {
502
		return obj && typeof obj === "object" && "setInterval" in obj;
503
	},
504

  
505
	isNumeric: function( obj ) {
506
		return !isNaN( parseFloat(obj) ) && isFinite( obj );
507
	},
508

  
509
	type: function( obj ) {
510
		return obj == null ?
511
			String( obj ) :
512
			class2type[ toString.call(obj) ] || "object";
513
	},
514

  
515
	isPlainObject: function( obj ) {
516
		// Must be an Object.
517
		// Because of IE, we also have to check the presence of the constructor property.
518
		// Make sure that DOM nodes and window objects don't pass through, as well
519
		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
520
			return false;
521
		}
522

  
523
		try {
524
			// Not own constructor property must be Object
525
			if ( obj.constructor &&
526
				!hasOwn.call(obj, "constructor") &&
527
				!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
528
				return false;
529
			}
530
		} catch ( e ) {
531
			// IE8,9 Will throw exceptions on certain host objects #9897
532
			return false;
533
		}
534

  
535
		// Own properties are enumerated firstly, so to speed up,
536
		// if last one is own, then all properties are own.
537

  
538
		var key;
539
		for ( key in obj ) {}
540

  
541
		return key === undefined || hasOwn.call( obj, key );
542
	},
543

  
544
	isEmptyObject: function( obj ) {
545
		for ( var name in obj ) {
546
			return false;
547
		}
548
		return true;
549
	},
550

  
551
	error: function( msg ) {
552
		throw new Error( msg );
553
	},
554

  
555
	parseJSON: function( data ) {
556
		if ( typeof data !== "string" || !data ) {
557
			return null;
558
		}
559

  
560
		// Make sure leading/trailing whitespace is removed (IE can't handle it)
561
		data = jQuery.trim( data );
562

  
563
		// Attempt to parse using the native JSON parser first
564
		if ( window.JSON && window.JSON.parse ) {
565
			return window.JSON.parse( data );
566
		}
567

  
568
		// Make sure the incoming data is actual JSON
569
		// Logic borrowed from http://json.org/json2.js
570
		if ( rvalidchars.test( data.replace( rvalidescape, "@" )
571
			.replace( rvalidtokens, "]" )
572
			.replace( rvalidbraces, "")) ) {
573

  
574
			return ( new Function( "return " + data ) )();
575

  
576
		}
577
		jQuery.error( "Invalid JSON: " + data );
578
	},
579

  
580
	// Cross-browser xml parsing
581
	parseXML: function( data ) {
582
		var xml, tmp;
583
		try {
584
			if ( window.DOMParser ) { // Standard
585
				tmp = new DOMParser();
586
				xml = tmp.parseFromString( data , "text/xml" );
587
			} else { // IE
588
				xml = new ActiveXObject( "Microsoft.XMLDOM" );
589
				xml.async = "false";
590
				xml.loadXML( data );
591
			}
592
		} catch( e ) {
593
			xml = undefined;
594
		}
595
		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
596
			jQuery.error( "Invalid XML: " + data );
597
		}
598
		return xml;
599
	},
600

  
601
	noop: function() {},
602

  
603
	// Evaluates a script in a global context
604
	// Workarounds based on findings by Jim Driscoll
605
	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
606
	globalEval: function( data ) {
607
		if ( data && rnotwhite.test( data ) ) {
608
			// We use execScript on Internet Explorer
609
			// We use an anonymous function so that context is window
610
			// rather than jQuery in Firefox
611
			( window.execScript || function( data ) {
612
				window[ "eval" ].call( window, data );
613
			} )( data );
614
		}
615
	},
616

  
617
	// Convert dashed to camelCase; used by the css and data modules
618
	// Microsoft forgot to hump their vendor prefix (#9572)
619
	camelCase: function( string ) {
620
		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
621
	},
622

  
623
	nodeName: function( elem, name ) {
624
		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
625
	},
626

  
627
	// args is for internal usage only
628
	each: function( object, callback, args ) {
629
		var name, i = 0,
630
			length = object.length,
631
			isObj = length === undefined || jQuery.isFunction( object );
632

  
633
		if ( args ) {
634
			if ( isObj ) {
635
				for ( name in object ) {
636
					if ( callback.apply( object[ name ], args ) === false ) {
637
						break;
638
					}
639
				}
640
			} else {
641
				for ( ; i < length; ) {
642
					if ( callback.apply( object[ i++ ], args ) === false ) {
643
						break;
644
					}
645
				}
646
			}
647

  
648
		// A special, fast, case for the most common use of each
649
		} else {
650
			if ( isObj ) {
651
				for ( name in object ) {
652
					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
653
						break;
654
					}
655
				}
656
			} else {
657
				for ( ; i < length; ) {
658
					if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
659
						break;
660
					}
661
				}
662
			}
663
		}
664

  
665
		return object;
666
	},
667

  
668
	// Use native String.trim function wherever possible
669
	trim: trim ?
670
		function( text ) {
671
			return text == null ?
672
				"" :
673
				trim.call( text );
674
		} :
675

  
676
		// Otherwise use our own trimming functionality
677
		function( text ) {
678
			return text == null ?
679
				"" :
680
				text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
681
		},
682

  
683
	// results is for internal usage only
684
	makeArray: function( array, results ) {
685
		var ret = results || [];
686

  
687
		if ( array != null ) {
688
			// The window, strings (and functions) also have 'length'
689
			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
690
			var type = jQuery.type( array );
691

  
692
			if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
693
				push.call( ret, array );
694
			} else {
695
				jQuery.merge( ret, array );
696
			}
697
		}
698

  
699
		return ret;
700
	},
701

  
702
	inArray: function( elem, array, i ) {
703
		var len;
704

  
705
		if ( array ) {
706
			if ( indexOf ) {
707
				return indexOf.call( array, elem, i );
708
			}
709

  
710
			len = array.length;
711
			i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
712

  
713
			for ( ; i < len; i++ ) {
714
				// Skip accessing in sparse arrays
715
				if ( i in array && array[ i ] === elem ) {
716
					return i;
717
				}
718
			}
719
		}
720

  
721
		return -1;
722
	},
723

  
724
	merge: function( first, second ) {
725
		var i = first.length,
726
			j = 0;
727

  
728
		if ( typeof second.length === "number" ) {
729
			for ( var l = second.length; j < l; j++ ) {
730
				first[ i++ ] = second[ j ];
731
			}
732

  
733
		} else {
734
			while ( second[j] !== undefined ) {
735
				first[ i++ ] = second[ j++ ];
736
			}
737
		}
738

  
739
		first.length = i;
740

  
741
		return first;
742
	},
743

  
744
	grep: function( elems, callback, inv ) {
745
		var ret = [], retVal;
746
		inv = !!inv;
747

  
748
		// Go through the array, only saving the items
749
		// that pass the validator function
750
		for ( var i = 0, length = elems.length; i < length; i++ ) {
751
			retVal = !!callback( elems[ i ], i );
752
			if ( inv !== retVal ) {
753
				ret.push( elems[ i ] );
754
			}
755
		}
756

  
757
		return ret;
758
	},
759

  
760
	// arg is for internal usage only
761
	map: function( elems, callback, arg ) {
762
		var value, key, ret = [],
763
			i = 0,
764
			length = elems.length,
765
			// jquery objects are treated as arrays
766
			isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
767

  
768
		// Go through the array, translating each of the items to their
769
		if ( isArray ) {
770
			for ( ; i < length; i++ ) {
771
				value = callback( elems[ i ], i, arg );
772

  
773
				if ( value != null ) {
774
					ret[ ret.length ] = value;
775
				}
776
			}
777

  
778
		// Go through every key on the object,
779
		} else {
780
			for ( key in elems ) {
781
				value = callback( elems[ key ], key, arg );
782

  
783
				if ( value != null ) {
784
					ret[ ret.length ] = value;
785
				}
786
			}
787
		}
788

  
789
		// Flatten any nested arrays
790
		return ret.concat.apply( [], ret );
791
	},
792

  
793
	// A global GUID counter for objects
794
	guid: 1,
795

  
796
	// Bind a function to a context, optionally partially applying any
797
	// arguments.
798
	proxy: function( fn, context ) {
799
		if ( typeof context === "string" ) {
800
			var tmp = fn[ context ];
801
			context = fn;
802
			fn = tmp;
803
		}
804

  
805
		// Quick check to determine if target is callable, in the spec
806
		// this throws a TypeError, but we will just return undefined.
807
		if ( !jQuery.isFunction( fn ) ) {
808
			return undefined;
809
		}
810

  
811
		// Simulated bind
812
		var args = slice.call( arguments, 2 ),
813
			proxy = function() {
814
				return fn.apply( context, args.concat( slice.call( arguments ) ) );
815
			};
816

  
817
		// Set the guid of unique handler to the same of original handler, so it can be removed
818
		proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
819

  
820
		return proxy;
821
	},
822

  
823
	// Mutifunctional method to get and set values to a collection
824
	// The value/s can optionally be executed if it's a function
825
	access: function( elems, key, value, exec, fn, pass ) {
826
		var length = elems.length;
827

  
828
		// Setting many attributes
829
		if ( typeof key === "object" ) {
830
			for ( var k in key ) {
831
				jQuery.access( elems, k, key[k], exec, fn, value );
832
			}
833
			return elems;
834
		}
835

  
836
		// Setting one attribute
837
		if ( value !== undefined ) {
838
			// Optionally, function values get executed if exec is true
839
			exec = !pass && exec && jQuery.isFunction(value);
840

  
841
			for ( var i = 0; i < length; i++ ) {
842
				fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
843
			}
844

  
845
			return elems;
846
		}
847

  
848
		// Getting an attribute
849
		return length ? fn( elems[0], key ) : undefined;
850
	},
851

  
852
	now: function() {
853
		return ( new Date() ).getTime();
854
	},
855

  
856
	// Use of jQuery.browser is frowned upon.
857
	// More details: http://docs.jquery.com/Utilities/jQuery.browser
858
	uaMatch: function( ua ) {
859
		ua = ua.toLowerCase();
860

  
861
		var match = rwebkit.exec( ua ) ||
862
			ropera.exec( ua ) ||
863
			rmsie.exec( ua ) ||
864
			ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
865
			[];
866

  
867
		return { browser: match[1] || "", version: match[2] || "0" };
868
	},
869

  
870
	sub: function() {
871
		function jQuerySub( selector, context ) {
872
			return new jQuerySub.fn.init( selector, context );
873
		}
874
		jQuery.extend( true, jQuerySub, this );
875
		jQuerySub.superclass = this;
876
		jQuerySub.fn = jQuerySub.prototype = this();
877
		jQuerySub.fn.constructor = jQuerySub;
878
		jQuerySub.sub = this.sub;
879
		jQuerySub.fn.init = function init( selector, context ) {
880
			if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
881
				context = jQuerySub( context );
882
			}
883

  
884
			return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
885
		};
886
		jQuerySub.fn.init.prototype = jQuerySub.fn;
887
		var rootjQuerySub = jQuerySub(document);
888
		return jQuerySub;
889
	},
890

  
891
	browser: {}
892
});
893

  
894
// Populate the class2type map
895
jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
896
	class2type[ "[object " + name + "]" ] = name.toLowerCase();
897
});
898

  
899
browserMatch = jQuery.uaMatch( userAgent );
900
if ( browserMatch.browser ) {
901
	jQuery.browser[ browserMatch.browser ] = true;
902
	jQuery.browser.version = browserMatch.version;
903
}
904

  
905
// Deprecated, use jQuery.browser.webkit instead
906
if ( jQuery.browser.webkit ) {
907
	jQuery.browser.safari = true;
908
}
909

  
910
// IE doesn't match non-breaking spaces with \s
911
if ( rnotwhite.test( "\xA0" ) ) {
912
	trimLeft = /^[\s\xA0]+/;
913
	trimRight = /[\s\xA0]+$/;
914
}
915

  
916
// All jQuery objects should point back to these
917
rootjQuery = jQuery(document);
918

  
919
// Cleanup functions for the document ready method
920
if ( document.addEventListener ) {
921
	DOMContentLoaded = function() {
922
		document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
923
		jQuery.ready();
924
	};
925

  
926
} else if ( document.attachEvent ) {
927
	DOMContentLoaded = function() {
928
		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
929
		if ( document.readyState === "complete" ) {
930
			document.detachEvent( "onreadystatechange", DOMContentLoaded );
931
			jQuery.ready();
932
		}
933
	};
934
}
935

  
936
// The DOM ready check for Internet Explorer
937
function doScrollCheck() {
938
	if ( jQuery.isReady ) {
939
		return;
940
	}
941

  
942
	try {
943
		// If IE is used, use the trick by Diego Perini
944
		// http://javascript.nwbox.com/IEContentLoaded/
945
		document.documentElement.doScroll("left");
946
	} catch(e) {
947
		setTimeout( doScrollCheck, 1 );
948
		return;
949
	}
950

  
951
	// and execute any waiting functions
952
	jQuery.ready();
953
}
954

  
955
return jQuery;
956

  
957
})();
958

  
959

  
960
// String to Object flags format cache
961
var flagsCache = {};
962

  
963
// Convert String-formatted flags into Object-formatted ones and store in cache
964
function createFlags( flags ) {
965
	var object = flagsCache[ flags ] = {},
966
		i, length;
967
	flags = flags.split( /\s+/ );
968
	for ( i = 0, length = flags.length; i < length; i++ ) {
969
		object[ flags[i] ] = true;
970
	}
971
	return object;
972
}
973

  
974
/*
975
 * Create a callback list using the following parameters:
976
 *
977
 *	flags:	an optional list of space-separated flags that will change how
978
 *			the callback list behaves
979
 *
980
 * By default a callback list will act like an event callback list and can be
981
 * "fired" multiple times.
982
 *
983
 * Possible flags:
984
 *
985
 *	once:			will ensure the callback list can only be fired once (like a Deferred)
986
 *
987
 *	memory:			will keep track of previous values and will call any callback added
988
 *					after the list has been fired right away with the latest "memorized"
989
 *					values (like a Deferred)
990
 *
991
 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
992
 *
993
 *	stopOnFalse:	interrupt callings when a callback returns false
994
 *
995
 */
996
jQuery.Callbacks = function( flags ) {
997

  
998
	// Convert flags from String-formatted to Object-formatted
999
	// (we check in cache first)
1000
	flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {};
1001

  
1002
	var // Actual callback list
1003
		list = [],
1004
		// Stack of fire calls for repeatable lists
1005
		stack = [],
1006
		// Last fire value (for non-forgettable lists)
1007
		memory,
1008
		// Flag to know if list is currently firing
1009
		firing,
1010
		// First callback to fire (used internally by add and fireWith)
1011
		firingStart,
1012
		// End of the loop when firing
1013
		firingLength,
1014
		// Index of currently firing callback (modified by remove if needed)
1015
		firingIndex,
1016
		// Add one or several callbacks to the list
1017
		add = function( args ) {
1018
			var i,
1019
				length,
1020
				elem,
1021
				type,
1022
				actual;
1023
			for ( i = 0, length = args.length; i < length; i++ ) {
1024
				elem = args[ i ];
1025
				type = jQuery.type( elem );
1026
				if ( type === "array" ) {
1027
					// Inspect recursively
1028
					add( elem );
1029
				} else if ( type === "function" ) {
1030
					// Add if not in unique mode and callback is not in
1031
					if ( !flags.unique || !self.has( elem ) ) {
1032
						list.push( elem );
1033
					}
1034
				}
1035
			}
1036
		},
1037
		// Fire callbacks
1038
		fire = function( context, args ) {
1039
			args = args || [];
1040
			memory = !flags.memory || [ context, args ];
1041
			firing = true;
1042
			firingIndex = firingStart || 0;
1043
			firingStart = 0;
1044
			firingLength = list.length;
1045
			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
1046
				if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) {
1047
					memory = true; // Mark as halted
1048
					break;
1049
				}
1050
			}
1051
			firing = false;
1052
			if ( list ) {
1053
				if ( !flags.once ) {
1054
					if ( stack && stack.length ) {
1055
						memory = stack.shift();
1056
						self.fireWith( memory[ 0 ], memory[ 1 ] );
1057
					}
1058
				} else if ( memory === true ) {
1059
					self.disable();
1060
				} else {
1061
					list = [];
1062
				}
1063
			}
1064
		},
1065
		// Actual Callbacks object
1066
		self = {
1067
			// Add a callback or a collection of callbacks to the list
1068
			add: function() {
1069
				if ( list ) {
1070
					var length = list.length;
1071
					add( arguments );
1072
					// Do we need to add the callbacks to the
1073
					// current firing batch?
1074
					if ( firing ) {
1075
						firingLength = list.length;
1076
					// With memory, if we're not firing then
1077
					// we should call right away, unless previous
1078
					// firing was halted (stopOnFalse)
1079
					} else if ( memory && memory !== true ) {
1080
						firingStart = length;
1081
						fire( memory[ 0 ], memory[ 1 ] );
1082
					}
1083
				}
1084
				return this;
1085
			},
1086
			// Remove a callback from the list
1087
			remove: function() {
1088
				if ( list ) {
1089
					var args = arguments,
1090
						argIndex = 0,
1091
						argLength = args.length;
1092
					for ( ; argIndex < argLength ; argIndex++ ) {
1093
						for ( var i = 0; i < list.length; i++ ) {
1094
							if ( args[ argIndex ] === list[ i ] ) {
1095
								// Handle firingIndex and firingLength
1096
								if ( firing ) {
1097
									if ( i <= firingLength ) {
1098
										firingLength--;
1099
										if ( i <= firingIndex ) {
1100
											firingIndex--;
1101
										}
1102
									}
1103
								}
1104
								// Remove the element
1105
								list.splice( i--, 1 );
1106
								// If we have some unicity property then
1107
								// we only need to do this once
1108
								if ( flags.unique ) {
1109
									break;
1110
								}
1111
							}
1112
						}
1113
					}
1114
				}
1115
				return this;
1116
			},
1117
			// Control if a given callback is in the list
1118
			has: function( fn ) {
1119
				if ( list ) {
1120
					var i = 0,
1121
						length = list.length;
1122
					for ( ; i < length; i++ ) {
1123
						if ( fn === list[ i ] ) {
1124
							return true;
1125
						}
1126
					}
1127
				}
1128
				return false;
1129
			},
1130
			// Remove all callbacks from the list
1131
			empty: function() {
1132
				list = [];
1133
				return this;
1134
			},
1135
			// Have the list do nothing anymore
1136
			disable: function() {
1137
				list = stack = memory = undefined;
1138
				return this;
1139
			},
1140
			// Is it disabled?
1141
			disabled: function() {
1142
				return !list;
1143
			},
1144
			// Lock the list in its current state
1145
			lock: function() {
1146
				stack = undefined;
1147
				if ( !memory || memory === true ) {
1148
					self.disable();
1149
				}
1150
				return this;
1151
			},
1152
			// Is it locked?
1153
			locked: function() {
1154
				return !stack;
1155
			},
1156
			// Call all callbacks with the given context and arguments
1157
			fireWith: function( context, args ) {
1158
				if ( stack ) {
1159
					if ( firing ) {
1160
						if ( !flags.once ) {
1161
							stack.push( [ context, args ] );
1162
						}
1163
					} else if ( !( flags.once && memory ) ) {
1164
						fire( context, args );
1165
					}
1166
				}
1167
				return this;
1168
			},
1169
			// Call all the callbacks with the given arguments
1170
			fire: function() {
1171
				self.fireWith( this, arguments );
1172
				return this;
1173
			},
1174
			// To know if the callbacks have already been called at least once
1175
			fired: function() {
1176
				return !!memory;
1177
			}
1178
		};
1179

  
1180
	return self;
1181
};
1182

  
1183

  
1184

  
1185

  
1186
var // Static reference to slice
1187
	sliceDeferred = [].slice;
1188

  
1189
jQuery.extend({
1190

  
1191
	Deferred: function( func ) {
1192
		var doneList = jQuery.Callbacks( "once memory" ),
1193
			failList = jQuery.Callbacks( "once memory" ),
1194
			progressList = jQuery.Callbacks( "memory" ),
1195
			state = "pending",
1196
			lists = {
1197
				resolve: doneList,
1198
				reject: failList,
1199
				notify: progressList
1200
			},
1201
			promise = {
1202
				done: doneList.add,
1203
				fail: failList.add,
1204
				progress: progressList.add,
1205

  
1206
				state: function() {
1207
					return state;
1208
				},
1209

  
1210
				// Deprecated
1211
				isResolved: doneList.fired,
1212
				isRejected: failList.fired,
1213

  
1214
				then: function( doneCallbacks, failCallbacks, progressCallbacks ) {
1215
					deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks );
1216
					return this;
1217
				},
1218
				always: function() {
1219
					deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments );
1220
					return this;
1221
				},
1222
				pipe: function( fnDone, fnFail, fnProgress ) {
1223
					return jQuery.Deferred(function( newDefer ) {
1224
						jQuery.each( {
1225
							done: [ fnDone, "resolve" ],
1226
							fail: [ fnFail, "reject" ],
1227
							progress: [ fnProgress, "notify" ]
1228
						}, function( handler, data ) {
1229
							var fn = data[ 0 ],
1230
								action = data[ 1 ],
1231
								returned;
1232
							if ( jQuery.isFunction( fn ) ) {
1233
								deferred[ handler ](function() {
1234
									returned = fn.apply( this, arguments );
1235
									if ( returned && jQuery.isFunction( returned.promise ) ) {
1236
										returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify );
1237
									} else {
1238
										newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
1239
									}
1240
								});
1241
							} else {
1242
								deferred[ handler ]( newDefer[ action ] );
1243
							}
1244
						});
1245
					}).promise();
1246
				},
1247
				// Get a promise for this deferred
1248
				// If obj is provided, the promise aspect is added to the object
1249
				promise: function( obj ) {
1250
					if ( obj == null ) {
1251
						obj = promise;
1252
					} else {
1253
						for ( var key in promise ) {
1254
							obj[ key ] = promise[ key ];
1255
						}
1256
					}
1257
					return obj;
1258
				}
1259
			},
1260
			deferred = promise.promise({}),
1261
			key;
1262

  
1263
		for ( key in lists ) {
1264
			deferred[ key ] = lists[ key ].fire;
1265
			deferred[ key + "With" ] = lists[ key ].fireWith;
1266
		}
1267

  
1268
		// Handle state
1269
		deferred.done( function() {
1270
			state = "resolved";
1271
		}, failList.disable, progressList.lock ).fail( function() {
1272
			state = "rejected";
1273
		}, doneList.disable, progressList.lock );
1274

  
1275
		// Call given func if any
1276
		if ( func ) {
1277
			func.call( deferred, deferred );
1278
		}
1279

  
1280
		// All done!
1281
		return deferred;
1282
	},
1283

  
1284
	// Deferred helper
1285
	when: function( firstParam ) {
1286
		var args = sliceDeferred.call( arguments, 0 ),
1287
			i = 0,
1288
			length = args.length,
1289
			pValues = new Array( length ),
1290
			count = length,
1291
			pCount = length,
1292
			deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
1293
				firstParam :
1294
				jQuery.Deferred(),
1295
			promise = deferred.promise();
1296
		function resolveFunc( i ) {
1297
			return function( value ) {
1298
				args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1299
				if ( !( --count ) ) {
1300
					deferred.resolveWith( deferred, args );
1301
				}
1302
			};
1303
		}
1304
		function progressFunc( i ) {
1305
			return function( value ) {
1306
				pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1307
				deferred.notifyWith( promise, pValues );
1308
			};
1309
		}
1310
		if ( length > 1 ) {
1311
			for ( ; i < length; i++ ) {
1312
				if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) {
1313
					args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) );
1314
				} else {
1315
					--count;
1316
				}
1317
			}
1318
			if ( !count ) {
1319
				deferred.resolveWith( deferred, args );
1320
			}
1321
		} else if ( deferred !== firstParam ) {
1322
			deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
1323
		}
1324
		return promise;
1325
	}
1326
});
1327

  
1328

  
1329

  
1330

  
1331
jQuery.support = (function() {
1332

  
1333
	var support,
1334
		all,
1335
		a,
1336
		select,
1337
		opt,
1338
		input,
1339
		marginDiv,
1340
		fragment,
1341
		tds,
1342
		events,
1343
		eventName,
1344
		i,
1345
		isSupported,
1346
		div = document.createElement( "div" ),
1347
		documentElement = document.documentElement;
1348

  
1349
	// Preliminary tests
1350
	div.setAttribute("className", "t");
1351
	div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
1352

  
1353
	all = div.getElementsByTagName( "*" );
1354
	a = div.getElementsByTagName( "a" )[ 0 ];
1355

  
1356
	// Can't get basic test support
1357
	if ( !all || !all.length || !a ) {
1358
		return {};
1359
	}
1360

  
1361
	// First batch of supports tests
1362
	select = document.createElement( "select" );
1363
	opt = select.appendChild( document.createElement("option") );
1364
	input = div.getElementsByTagName( "input" )[ 0 ];
1365

  
1366
	support = {
1367
		// IE strips leading whitespace when .innerHTML is used
1368
		leadingWhitespace: ( div.firstChild.nodeType === 3 ),
1369

  
1370
		// Make sure that tbody elements aren't automatically inserted
1371
		// IE will insert them into empty tables
1372
		tbody: !div.getElementsByTagName("tbody").length,
1373

  
1374
		// Make sure that link elements get serialized correctly by innerHTML
1375
		// This requires a wrapper element in IE
1376
		htmlSerialize: !!div.getElementsByTagName("link").length,
1377

  
1378
		// Get the style information from getAttribute
1379
		// (IE uses .cssText instead)
1380
		style: /top/.test( a.getAttribute("style") ),
1381

  
1382
		// Make sure that URLs aren't manipulated
1383
		// (IE normalizes it by default)
1384
		hrefNormalized: ( a.getAttribute("href") === "/a" ),
1385

  
1386
		// Make sure that element opacity exists
1387
		// (IE uses filter instead)
1388
		// Use a regex to work around a WebKit issue. See #5145
1389
		opacity: /^0.55/.test( a.style.opacity ),
1390

  
1391
		// Verify style float existence
1392
		// (IE uses styleFloat instead of cssFloat)
1393
		cssFloat: !!a.style.cssFloat,
1394

  
1395
		// Make sure that if no value is specified for a checkbox
1396
		// that it defaults to "on".
1397
		// (WebKit defaults to "" instead)
1398
		checkOn: ( input.value === "on" ),
1399

  
1400
		// Make sure that a selected-by-default option has a working selected property.
1401
		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1402
		optSelected: opt.selected,
1403

  
1404
		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1405
		getSetAttribute: div.className !== "t",
1406

  
1407
		// Tests for enctype support on a form(#6743)
1408
		enctype: !!document.createElement("form").enctype,
1409

  
1410
		// Makes sure cloning an html5 element does not cause problems
1411
		// Where outerHTML is undefined, this still works
1412
		html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
1413

  
1414
		// Will be defined later
1415
		submitBubbles: true,
1416
		changeBubbles: true,
1417
		focusinBubbles: false,
1418
		deleteExpando: true,
1419
		noCloneEvent: true,
1420
		inlineBlockNeedsLayout: false,
1421
		shrinkWrapBlocks: false,
1422
		reliableMarginRight: true
1423
	};
1424

  
1425
	// Make sure checked status is properly cloned
1426
	input.checked = true;
1427
	support.noCloneChecked = input.cloneNode( true ).checked;
1428

  
1429
	// Make sure that the options inside disabled selects aren't marked as disabled
1430
	// (WebKit marks them as disabled)
1431
	select.disabled = true;
1432
	support.optDisabled = !opt.disabled;
1433

  
1434
	// Test to see if it's possible to delete an expando from an element
1435
	// Fails in Internet Explorer
1436
	try {
1437
		delete div.test;
1438
	} catch( e ) {
1439
		support.deleteExpando = false;
1440
	}
1441

  
1442
	if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1443
		div.attachEvent( "onclick", function() {
1444
			// Cloning a node shouldn't copy over any
1445
			// bound event handlers (IE does this)
1446
			support.noCloneEvent = false;
1447
		});
1448
		div.cloneNode( true ).fireEvent( "onclick" );
1449
	}
1450

  
1451
	// Check if a radio maintains its value
1452
	// after being appended to the DOM
1453
	input = document.createElement("input");
1454
	input.value = "t";
1455
	input.setAttribute("type", "radio");
1456
	support.radioValue = input.value === "t";
1457

  
1458
	input.setAttribute("checked", "checked");
1459
	div.appendChild( input );
1460
	fragment = document.createDocumentFragment();
1461
	fragment.appendChild( div.lastChild );
1462

  
1463
	// WebKit doesn't clone checked state correctly in fragments
1464
	support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
1465

  
1466
	// Check if a disconnected checkbox will retain its checked
1467
	// value of true after appended to the DOM (IE6/7)
1468
	support.appendChecked = input.checked;
1469

  
1470
	fragment.removeChild( input );
1471
	fragment.appendChild( div );
1472

  
1473
	div.innerHTML = "";
1474

  
1475
	// Check if div with explicit width and no margin-right incorrectly
1476
	// gets computed margin-right based on width of container. For more
1477
	// info see bug #3333
1478
	// Fails in WebKit before Feb 2011 nightlies
1479
	// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1480
	if ( window.getComputedStyle ) {
1481
		marginDiv = document.createElement( "div" );
1482
		marginDiv.style.width = "0";
1483
		marginDiv.style.marginRight = "0";
1484
		div.style.width = "2px";
1485
		div.appendChild( marginDiv );
1486
		support.reliableMarginRight =
1487
			( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
1488
	}
1489

  
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff