/hyde/tests/ext/uglify/jquery.js

Large files files are truncated, but you can click here to view the full file

   1/*!
   2 * jQuery JavaScript Library v1.5.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: Wed Feb 23 13:55:29 2011 -0500
  15 */
  16(function( window, undefined ) {
  17
  18// Use the correct document accordingly with window argument (sandbox)
  19var document = window.document;
  20var jQuery = (function() {
  21
  22// Define a local copy of jQuery
  23var jQuery = function( selector, context ) {
  24		// The jQuery object is actually just the init constructor 'enhanced'
  25		return new jQuery.fn.init( selector, context, rootjQuery );
  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)
  39	quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/,
  40
  41	// Check if a string has a non-whitespace character in it
  42	rnotwhite = /\S/,
  43
  44	// Used for trimming whitespace
  45	trimLeft = /^\s+/,
  46	trimRight = /\s+$/,
  47
  48	// Check for digits
  49	rdigit = /\d/,
  50
  51	// Match a standalone tag
  52	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
  53
  54	// JSON RegExp
  55	rvalidchars = /^[\],:{}\s]*$/,
  56	rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
  57	rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
  58	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
  59
  60	// Useragent RegExp
  61	rwebkit = /(webkit)[ \/]([\w.]+)/,
  62	ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
  63	rmsie = /(msie) ([\w.]+)/,
  64	rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
  65
  66	// Keep a UserAgent string for use with jQuery.browser
  67	userAgent = navigator.userAgent,
  68
  69	// For matching the engine and version of the browser
  70	browserMatch,
  71
  72	// Has the ready events already been bound?
  73	readyBound = false,
  74
  75	// The deferred used on DOM ready
  76	readyList,
  77
  78	// Promise methods
  79	promiseMethods = "then done fail isResolved isRejected promise".split( " " ),
  80
  81	// The ready event handler
  82	DOMContentLoaded,
  83
  84	// Save a reference to some core methods
  85	toString = Object.prototype.toString,
  86	hasOwn = Object.prototype.hasOwnProperty,
  87	push = Array.prototype.push,
  88	slice = Array.prototype.slice,
  89	trim = String.prototype.trim,
  90	indexOf = Array.prototype.indexOf,
  91
  92	// [[Class]] -> type pairs
  93	class2type = {};
  94
  95jQuery.fn = jQuery.prototype = {
  96	constructor: jQuery,
  97	init: function( selector, context, rootjQuery ) {
  98		var match, elem, ret, doc;
  99
 100		// Handle $(""), $(null), or $(undefined)
 101		if ( !selector ) {
 102			return this;
 103		}
 104
 105		// Handle $(DOMElement)
 106		if ( selector.nodeType ) {
 107			this.context = this[0] = selector;
 108			this.length = 1;
 109			return this;
 110		}
 111
 112		// The body element only exists once, optimize finding it
 113		if ( selector === "body" && !context && document.body ) {
 114			this.context = document;
 115			this[0] = document.body;
 116			this.selector = "body";
 117			this.length = 1;
 118			return this;
 119		}
 120
 121		// Handle HTML strings
 122		if ( typeof selector === "string" ) {
 123			// Are we dealing with HTML string or an ID?
 124			match = quickExpr.exec( selector );
 125
 126			// Verify a match, and that no context was specified for #id
 127			if ( match && (match[1] || !context) ) {
 128
 129				// HANDLE: $(html) -> $(array)
 130				if ( match[1] ) {
 131					context = context instanceof jQuery ? context[0] : context;
 132					doc = (context ? context.ownerDocument || context : document);
 133
 134					// If a single string is passed in and it's a single tag
 135					// just do a createElement and skip the rest
 136					ret = rsingleTag.exec( selector );
 137
 138					if ( ret ) {
 139						if ( jQuery.isPlainObject( context ) ) {
 140							selector = [ document.createElement( ret[1] ) ];
 141							jQuery.fn.attr.call( selector, context, true );
 142
 143						} else {
 144							selector = [ doc.createElement( ret[1] ) ];
 145						}
 146
 147					} else {
 148						ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
 149						selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
 150					}
 151
 152					return jQuery.merge( this, selector );
 153
 154				// HANDLE: $("#id")
 155				} else {
 156					elem = document.getElementById( match[2] );
 157
 158					// Check parentNode to catch when Blackberry 4.6 returns
 159					// nodes that are no longer in the document #6963
 160					if ( elem && elem.parentNode ) {
 161						// Handle the case where IE and Opera return items
 162						// by name instead of ID
 163						if ( elem.id !== match[2] ) {
 164							return rootjQuery.find( selector );
 165						}
 166
 167						// Otherwise, we inject the element directly into the jQuery object
 168						this.length = 1;
 169						this[0] = elem;
 170					}
 171
 172					this.context = document;
 173					this.selector = selector;
 174					return this;
 175				}
 176
 177			// HANDLE: $(expr, $(...))
 178			} else if ( !context || context.jquery ) {
 179				return (context || rootjQuery).find( selector );
 180
 181			// HANDLE: $(expr, context)
 182			// (which is just equivalent to: $(context).find(expr)
 183			} else {
 184				return this.constructor( context ).find( selector );
 185			}
 186
 187		// HANDLE: $(function)
 188		// Shortcut for document ready
 189		} else if ( jQuery.isFunction( selector ) ) {
 190			return rootjQuery.ready( selector );
 191		}
 192
 193		if (selector.selector !== undefined) {
 194			this.selector = selector.selector;
 195			this.context = selector.context;
 196		}
 197
 198		return jQuery.makeArray( selector, this );
 199	},
 200
 201	// Start with an empty selector
 202	selector: "",
 203
 204	// The current version of jQuery being used
 205	jquery: "1.5.1",
 206
 207	// The default length of a jQuery object is 0
 208	length: 0,
 209
 210	// The number of elements contained in the matched element set
 211	size: function() {
 212		return this.length;
 213	},
 214
 215	toArray: function() {
 216		return slice.call( this, 0 );
 217	},
 218
 219	// Get the Nth element in the matched element set OR
 220	// Get the whole matched element set as a clean array
 221	get: function( num ) {
 222		return num == null ?
 223
 224			// Return a 'clean' array
 225			this.toArray() :
 226
 227			// Return just the object
 228			( num < 0 ? this[ this.length + num ] : this[ num ] );
 229	},
 230
 231	// Take an array of elements and push it onto the stack
 232	// (returning the new matched element set)
 233	pushStack: function( elems, name, selector ) {
 234		// Build a new jQuery matched element set
 235		var ret = this.constructor();
 236
 237		if ( jQuery.isArray( elems ) ) {
 238			push.apply( ret, elems );
 239
 240		} else {
 241			jQuery.merge( ret, elems );
 242		}
 243
 244		// Add the old object onto the stack (as a reference)
 245		ret.prevObject = this;
 246
 247		ret.context = this.context;
 248
 249		if ( name === "find" ) {
 250			ret.selector = this.selector + (this.selector ? " " : "") + selector;
 251		} else if ( name ) {
 252			ret.selector = this.selector + "." + name + "(" + selector + ")";
 253		}
 254
 255		// Return the newly-formed element set
 256		return ret;
 257	},
 258
 259	// Execute a callback for every element in the matched set.
 260	// (You can seed the arguments with an array of args, but this is
 261	// only used internally.)
 262	each: function( callback, args ) {
 263		return jQuery.each( this, callback, args );
 264	},
 265
 266	ready: function( fn ) {
 267		// Attach the listeners
 268		jQuery.bindReady();
 269
 270		// Add the callback
 271		readyList.done( fn );
 272
 273		return this;
 274	},
 275
 276	eq: function( i ) {
 277		return i === -1 ?
 278			this.slice( i ) :
 279			this.slice( i, +i + 1 );
 280	},
 281
 282	first: function() {
 283		return this.eq( 0 );
 284	},
 285
 286	last: function() {
 287		return this.eq( -1 );
 288	},
 289
 290	slice: function() {
 291		return this.pushStack( slice.apply( this, arguments ),
 292			"slice", slice.call(arguments).join(",") );
 293	},
 294
 295	map: function( callback ) {
 296		return this.pushStack( jQuery.map(this, function( elem, i ) {
 297			return callback.call( elem, i, elem );
 298		}));
 299	},
 300
 301	end: function() {
 302		return this.prevObject || this.constructor(null);
 303	},
 304
 305	// For internal use only.
 306	// Behaves like an Array's method, not like a jQuery method.
 307	push: push,
 308	sort: [].sort,
 309	splice: [].splice
 310};
 311
 312// Give the init function the jQuery prototype for later instantiation
 313jQuery.fn.init.prototype = jQuery.fn;
 314
 315jQuery.extend = jQuery.fn.extend = function() {
 316	var options, name, src, copy, copyIsArray, clone,
 317		target = arguments[0] || {},
 318		i = 1,
 319		length = arguments.length,
 320		deep = false;
 321
 322	// Handle a deep copy situation
 323	if ( typeof target === "boolean" ) {
 324		deep = target;
 325		target = arguments[1] || {};
 326		// skip the boolean and the target
 327		i = 2;
 328	}
 329
 330	// Handle case when target is a string or something (possible in deep copy)
 331	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
 332		target = {};
 333	}
 334
 335	// extend jQuery itself if only one argument is passed
 336	if ( length === i ) {
 337		target = this;
 338		--i;
 339	}
 340
 341	for ( ; i < length; i++ ) {
 342		// Only deal with non-null/undefined values
 343		if ( (options = arguments[ i ]) != null ) {
 344			// Extend the base object
 345			for ( name in options ) {
 346				src = target[ name ];
 347				copy = options[ name ];
 348
 349				// Prevent never-ending loop
 350				if ( target === copy ) {
 351					continue;
 352				}
 353
 354				// Recurse if we're merging plain objects or arrays
 355				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
 356					if ( copyIsArray ) {
 357						copyIsArray = false;
 358						clone = src && jQuery.isArray(src) ? src : [];
 359
 360					} else {
 361						clone = src && jQuery.isPlainObject(src) ? src : {};
 362					}
 363
 364					// Never move original objects, clone them
 365					target[ name ] = jQuery.extend( deep, clone, copy );
 366
 367				// Don't bring in undefined values
 368				} else if ( copy !== undefined ) {
 369					target[ name ] = copy;
 370				}
 371			}
 372		}
 373	}
 374
 375	// Return the modified object
 376	return target;
 377};
 378
 379jQuery.extend({
 380	noConflict: function( deep ) {
 381		window.$ = _$;
 382
 383		if ( deep ) {
 384			window.jQuery = _jQuery;
 385		}
 386
 387		return jQuery;
 388	},
 389
 390	// Is the DOM ready to be used? Set to true once it occurs.
 391	isReady: false,
 392
 393	// A counter to track how many items to wait for before
 394	// the ready event fires. See #6781
 395	readyWait: 1,
 396
 397	// Handle when the DOM is ready
 398	ready: function( wait ) {
 399		// A third-party is pushing the ready event forwards
 400		if ( wait === true ) {
 401			jQuery.readyWait--;
 402		}
 403
 404		// Make sure that the DOM is not already loaded
 405		if ( !jQuery.readyWait || (wait !== true && !jQuery.isReady) ) {
 406			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
 407			if ( !document.body ) {
 408				return setTimeout( jQuery.ready, 1 );
 409			}
 410
 411			// Remember that the DOM is ready
 412			jQuery.isReady = true;
 413
 414			// If a normal DOM Ready event fired, decrement, and wait if need be
 415			if ( wait !== true && --jQuery.readyWait > 0 ) {
 416				return;
 417			}
 418
 419			// If there are functions bound, to execute
 420			readyList.resolveWith( document, [ jQuery ] );
 421
 422			// Trigger any bound ready events
 423			if ( jQuery.fn.trigger ) {
 424				jQuery( document ).trigger( "ready" ).unbind( "ready" );
 425			}
 426		}
 427	},
 428
 429	bindReady: function() {
 430		if ( readyBound ) {
 431			return;
 432		}
 433
 434		readyBound = true;
 435
 436		// Catch cases where $(document).ready() is called after the
 437		// browser event has already occurred.
 438		if ( document.readyState === "complete" ) {
 439			// Handle it asynchronously to allow scripts the opportunity to delay ready
 440			return setTimeout( jQuery.ready, 1 );
 441		}
 442
 443		// Mozilla, Opera and webkit nightlies currently support this event
 444		if ( document.addEventListener ) {
 445			// Use the handy event callback
 446			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
 447
 448			// A fallback to window.onload, that will always work
 449			window.addEventListener( "load", jQuery.ready, false );
 450
 451		// If IE event model is used
 452		} else if ( document.attachEvent ) {
 453			// ensure firing before onload,
 454			// maybe late but safe also for iframes
 455			document.attachEvent("onreadystatechange", DOMContentLoaded);
 456
 457			// A fallback to window.onload, that will always work
 458			window.attachEvent( "onload", jQuery.ready );
 459
 460			// If IE and not a frame
 461			// continually check to see if the document is ready
 462			var toplevel = false;
 463
 464			try {
 465				toplevel = window.frameElement == null;
 466			} catch(e) {}
 467
 468			if ( document.documentElement.doScroll && toplevel ) {
 469				doScrollCheck();
 470			}
 471		}
 472	},
 473
 474	// See test/unit/core.js for details concerning isFunction.
 475	// Since version 1.3, DOM methods and functions like alert
 476	// aren't supported. They return false on IE (#2968).
 477	isFunction: function( obj ) {
 478		return jQuery.type(obj) === "function";
 479	},
 480
 481	isArray: Array.isArray || function( obj ) {
 482		return jQuery.type(obj) === "array";
 483	},
 484
 485	// A crude way of determining if an object is a window
 486	isWindow: function( obj ) {
 487		return obj && typeof obj === "object" && "setInterval" in obj;
 488	},
 489
 490	isNaN: function( obj ) {
 491		return obj == null || !rdigit.test( obj ) || isNaN( obj );
 492	},
 493
 494	type: function( obj ) {
 495		return obj == null ?
 496			String( obj ) :
 497			class2type[ toString.call(obj) ] || "object";
 498	},
 499
 500	isPlainObject: function( obj ) {
 501		// Must be an Object.
 502		// Because of IE, we also have to check the presence of the constructor property.
 503		// Make sure that DOM nodes and window objects don't pass through, as well
 504		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
 505			return false;
 506		}
 507
 508		// Not own constructor property must be Object
 509		if ( obj.constructor &&
 510			!hasOwn.call(obj, "constructor") &&
 511			!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
 512			return false;
 513		}
 514
 515		// Own properties are enumerated firstly, so to speed up,
 516		// if last one is own, then all properties are own.
 517
 518		var key;
 519		for ( key in obj ) {}
 520
 521		return key === undefined || hasOwn.call( obj, key );
 522	},
 523
 524	isEmptyObject: function( obj ) {
 525		for ( var name in obj ) {
 526			return false;
 527		}
 528		return true;
 529	},
 530
 531	error: function( msg ) {
 532		throw msg;
 533	},
 534
 535	parseJSON: function( data ) {
 536		if ( typeof data !== "string" || !data ) {
 537			return null;
 538		}
 539
 540		// Make sure leading/trailing whitespace is removed (IE can't handle it)
 541		data = jQuery.trim( data );
 542
 543		// Make sure the incoming data is actual JSON
 544		// Logic borrowed from http://json.org/json2.js
 545		if ( rvalidchars.test(data.replace(rvalidescape, "@")
 546			.replace(rvalidtokens, "]")
 547			.replace(rvalidbraces, "")) ) {
 548
 549			// Try to use the native JSON parser first
 550			return window.JSON && window.JSON.parse ?
 551				window.JSON.parse( data ) :
 552				(new Function("return " + data))();
 553
 554		} else {
 555			jQuery.error( "Invalid JSON: " + data );
 556		}
 557	},
 558
 559	// Cross-browser xml parsing
 560	// (xml & tmp used internally)
 561	parseXML: function( data , xml , tmp ) {
 562
 563		if ( window.DOMParser ) { // Standard
 564			tmp = new DOMParser();
 565			xml = tmp.parseFromString( data , "text/xml" );
 566		} else { // IE
 567			xml = new ActiveXObject( "Microsoft.XMLDOM" );
 568			xml.async = "false";
 569			xml.loadXML( data );
 570		}
 571
 572		tmp = xml.documentElement;
 573
 574		if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
 575			jQuery.error( "Invalid XML: " + data );
 576		}
 577
 578		return xml;
 579	},
 580
 581	noop: function() {},
 582
 583	// Evalulates a script in a global context
 584	globalEval: function( data ) {
 585		if ( data && rnotwhite.test(data) ) {
 586			// Inspired by code by Andrea Giammarchi
 587			// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
 588			var head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement,
 589				script = document.createElement( "script" );
 590
 591			if ( jQuery.support.scriptEval() ) {
 592				script.appendChild( document.createTextNode( data ) );
 593			} else {
 594				script.text = data;
 595			}
 596
 597			// Use insertBefore instead of appendChild to circumvent an IE6 bug.
 598			// This arises when a base node is used (#2709).
 599			head.insertBefore( script, head.firstChild );
 600			head.removeChild( script );
 601		}
 602	},
 603
 604	nodeName: function( elem, name ) {
 605		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
 606	},
 607
 608	// args is for internal usage only
 609	each: function( object, callback, args ) {
 610		var name, i = 0,
 611			length = object.length,
 612			isObj = length === undefined || jQuery.isFunction(object);
 613
 614		if ( args ) {
 615			if ( isObj ) {
 616				for ( name in object ) {
 617					if ( callback.apply( object[ name ], args ) === false ) {
 618						break;
 619					}
 620				}
 621			} else {
 622				for ( ; i < length; ) {
 623					if ( callback.apply( object[ i++ ], args ) === false ) {
 624						break;
 625					}
 626				}
 627			}
 628
 629		// A special, fast, case for the most common use of each
 630		} else {
 631			if ( isObj ) {
 632				for ( name in object ) {
 633					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
 634						break;
 635					}
 636				}
 637			} else {
 638				for ( var value = object[0];
 639					i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
 640			}
 641		}
 642
 643		return object;
 644	},
 645
 646	// Use native String.trim function wherever possible
 647	trim: trim ?
 648		function( text ) {
 649			return text == null ?
 650				"" :
 651				trim.call( text );
 652		} :
 653
 654		// Otherwise use our own trimming functionality
 655		function( text ) {
 656			return text == null ?
 657				"" :
 658				text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
 659		},
 660
 661	// results is for internal usage only
 662	makeArray: function( array, results ) {
 663		var ret = results || [];
 664
 665		if ( array != null ) {
 666			// The window, strings (and functions) also have 'length'
 667			// The extra typeof function check is to prevent crashes
 668			// in Safari 2 (See: #3039)
 669			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
 670			var type = jQuery.type(array);
 671
 672			if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
 673				push.call( ret, array );
 674			} else {
 675				jQuery.merge( ret, array );
 676			}
 677		}
 678
 679		return ret;
 680	},
 681
 682	inArray: function( elem, array ) {
 683		if ( array.indexOf ) {
 684			return array.indexOf( elem );
 685		}
 686
 687		for ( var i = 0, length = array.length; i < length; i++ ) {
 688			if ( array[ i ] === elem ) {
 689				return i;
 690			}
 691		}
 692
 693		return -1;
 694	},
 695
 696	merge: function( first, second ) {
 697		var i = first.length,
 698			j = 0;
 699
 700		if ( typeof second.length === "number" ) {
 701			for ( var l = second.length; j < l; j++ ) {
 702				first[ i++ ] = second[ j ];
 703			}
 704
 705		} else {
 706			while ( second[j] !== undefined ) {
 707				first[ i++ ] = second[ j++ ];
 708			}
 709		}
 710
 711		first.length = i;
 712
 713		return first;
 714	},
 715
 716	grep: function( elems, callback, inv ) {
 717		var ret = [], retVal;
 718		inv = !!inv;
 719
 720		// Go through the array, only saving the items
 721		// that pass the validator function
 722		for ( var i = 0, length = elems.length; i < length; i++ ) {
 723			retVal = !!callback( elems[ i ], i );
 724			if ( inv !== retVal ) {
 725				ret.push( elems[ i ] );
 726			}
 727		}
 728
 729		return ret;
 730	},
 731
 732	// arg is for internal usage only
 733	map: function( elems, callback, arg ) {
 734		var ret = [], value;
 735
 736		// Go through the array, translating each of the items to their
 737		// new value (or values).
 738		for ( var i = 0, length = elems.length; i < length; i++ ) {
 739			value = callback( elems[ i ], i, arg );
 740
 741			if ( value != null ) {
 742				ret[ ret.length ] = value;
 743			}
 744		}
 745
 746		// Flatten any nested arrays
 747		return ret.concat.apply( [], ret );
 748	},
 749
 750	// A global GUID counter for objects
 751	guid: 1,
 752
 753	proxy: function( fn, proxy, thisObject ) {
 754		if ( arguments.length === 2 ) {
 755			if ( typeof proxy === "string" ) {
 756				thisObject = fn;
 757				fn = thisObject[ proxy ];
 758				proxy = undefined;
 759
 760			} else if ( proxy && !jQuery.isFunction( proxy ) ) {
 761				thisObject = proxy;
 762				proxy = undefined;
 763			}
 764		}
 765
 766		if ( !proxy && fn ) {
 767			proxy = function() {
 768				return fn.apply( thisObject || this, arguments );
 769			};
 770		}
 771
 772		// Set the guid of unique handler to the same of original handler, so it can be removed
 773		if ( fn ) {
 774			proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
 775		}
 776
 777		// So proxy can be declared as an argument
 778		return proxy;
 779	},
 780
 781	// Mutifunctional method to get and set values to a collection
 782	// The value/s can be optionally by executed if its a function
 783	access: function( elems, key, value, exec, fn, pass ) {
 784		var length = elems.length;
 785
 786		// Setting many attributes
 787		if ( typeof key === "object" ) {
 788			for ( var k in key ) {
 789				jQuery.access( elems, k, key[k], exec, fn, value );
 790			}
 791			return elems;
 792		}
 793
 794		// Setting one attribute
 795		if ( value !== undefined ) {
 796			// Optionally, function values get executed if exec is true
 797			exec = !pass && exec && jQuery.isFunction(value);
 798
 799			for ( var i = 0; i < length; i++ ) {
 800				fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
 801			}
 802
 803			return elems;
 804		}
 805
 806		// Getting an attribute
 807		return length ? fn( elems[0], key ) : undefined;
 808	},
 809
 810	now: function() {
 811		return (new Date()).getTime();
 812	},
 813
 814	// Create a simple deferred (one callbacks list)
 815	_Deferred: function() {
 816		var // callbacks list
 817			callbacks = [],
 818			// stored [ context , args ]
 819			fired,
 820			// to avoid firing when already doing so
 821			firing,
 822			// flag to know if the deferred has been cancelled
 823			cancelled,
 824			// the deferred itself
 825			deferred  = {
 826
 827				// done( f1, f2, ...)
 828				done: function() {
 829					if ( !cancelled ) {
 830						var args = arguments,
 831							i,
 832							length,
 833							elem,
 834							type,
 835							_fired;
 836						if ( fired ) {
 837							_fired = fired;
 838							fired = 0;
 839						}
 840						for ( i = 0, length = args.length; i < length; i++ ) {
 841							elem = args[ i ];
 842							type = jQuery.type( elem );
 843							if ( type === "array" ) {
 844								deferred.done.apply( deferred, elem );
 845							} else if ( type === "function" ) {
 846								callbacks.push( elem );
 847							}
 848						}
 849						if ( _fired ) {
 850							deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
 851						}
 852					}
 853					return this;
 854				},
 855
 856				// resolve with given context and args
 857				resolveWith: function( context, args ) {
 858					if ( !cancelled && !fired && !firing ) {
 859						firing = 1;
 860						try {
 861							while( callbacks[ 0 ] ) {
 862								callbacks.shift().apply( context, args );
 863							}
 864						}
 865						// We have to add a catch block for
 866						// IE prior to 8 or else the finally
 867						// block will never get executed
 868						catch (e) {
 869							throw e;
 870						}
 871						finally {
 872							fired = [ context, args ];
 873							firing = 0;
 874						}
 875					}
 876					return this;
 877				},
 878
 879				// resolve with this as context and given arguments
 880				resolve: function() {
 881					deferred.resolveWith( jQuery.isFunction( this.promise ) ? this.promise() : this, arguments );
 882					return this;
 883				},
 884
 885				// Has this deferred been resolved?
 886				isResolved: function() {
 887					return !!( firing || fired );
 888				},
 889
 890				// Cancel
 891				cancel: function() {
 892					cancelled = 1;
 893					callbacks = [];
 894					return this;
 895				}
 896			};
 897
 898		return deferred;
 899	},
 900
 901	// Full fledged deferred (two callbacks list)
 902	Deferred: function( func ) {
 903		var deferred = jQuery._Deferred(),
 904			failDeferred = jQuery._Deferred(),
 905			promise;
 906		// Add errorDeferred methods, then and promise
 907		jQuery.extend( deferred, {
 908			then: function( doneCallbacks, failCallbacks ) {
 909				deferred.done( doneCallbacks ).fail( failCallbacks );
 910				return this;
 911			},
 912			fail: failDeferred.done,
 913			rejectWith: failDeferred.resolveWith,
 914			reject: failDeferred.resolve,
 915			isRejected: failDeferred.isResolved,
 916			// Get a promise for this deferred
 917			// If obj is provided, the promise aspect is added to the object
 918			promise: function( obj ) {
 919				if ( obj == null ) {
 920					if ( promise ) {
 921						return promise;
 922					}
 923					promise = obj = {};
 924				}
 925				var i = promiseMethods.length;
 926				while( i-- ) {
 927					obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
 928				}
 929				return obj;
 930			}
 931		} );
 932		// Make sure only one callback list will be used
 933		deferred.done( failDeferred.cancel ).fail( deferred.cancel );
 934		// Unexpose cancel
 935		delete deferred.cancel;
 936		// Call given func if any
 937		if ( func ) {
 938			func.call( deferred, deferred );
 939		}
 940		return deferred;
 941	},
 942
 943	// Deferred helper
 944	when: function( object ) {
 945		var lastIndex = arguments.length,
 946			deferred = lastIndex <= 1 && object && jQuery.isFunction( object.promise ) ?
 947				object :
 948				jQuery.Deferred(),
 949			promise = deferred.promise();
 950
 951		if ( lastIndex > 1 ) {
 952			var array = slice.call( arguments, 0 ),
 953				count = lastIndex,
 954				iCallback = function( index ) {
 955					return function( value ) {
 956						array[ index ] = arguments.length > 1 ? slice.call( arguments, 0 ) : value;
 957						if ( !( --count ) ) {
 958							deferred.resolveWith( promise, array );
 959						}
 960					};
 961				};
 962			while( ( lastIndex-- ) ) {
 963				object = array[ lastIndex ];
 964				if ( object && jQuery.isFunction( object.promise ) ) {
 965					object.promise().then( iCallback(lastIndex), deferred.reject );
 966				} else {
 967					--count;
 968				}
 969			}
 970			if ( !count ) {
 971				deferred.resolveWith( promise, array );
 972			}
 973		} else if ( deferred !== object ) {
 974			deferred.resolve( object );
 975		}
 976		return promise;
 977	},
 978
 979	// Use of jQuery.browser is frowned upon.
 980	// More details: http://docs.jquery.com/Utilities/jQuery.browser
 981	uaMatch: function( ua ) {
 982		ua = ua.toLowerCase();
 983
 984		var match = rwebkit.exec( ua ) ||
 985			ropera.exec( ua ) ||
 986			rmsie.exec( ua ) ||
 987			ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
 988			[];
 989
 990		return { browser: match[1] || "", version: match[2] || "0" };
 991	},
 992
 993	sub: function() {
 994		function jQuerySubclass( selector, context ) {
 995			return new jQuerySubclass.fn.init( selector, context );
 996		}
 997		jQuery.extend( true, jQuerySubclass, this );
 998		jQuerySubclass.superclass = this;
 999		jQuerySubclass.fn = jQuerySubclass.prototype = this();
1000		jQuerySubclass.fn.constructor = jQuerySubclass;
1001		jQuerySubclass.subclass = this.subclass;
1002		jQuerySubclass.fn.init = function init( selector, context ) {
1003			if ( context && context instanceof jQuery && !(context instanceof jQuerySubclass) ) {
1004				context = jQuerySubclass(context);
1005			}
1006
1007			return jQuery.fn.init.call( this, selector, context, rootjQuerySubclass );
1008		};
1009		jQuerySubclass.fn.init.prototype = jQuerySubclass.fn;
1010		var rootjQuerySubclass = jQuerySubclass(document);
1011		return jQuerySubclass;
1012	},
1013
1014	browser: {}
1015});
1016
1017// Create readyList deferred
1018readyList = jQuery._Deferred();
1019
1020// Populate the class2type map
1021jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
1022	class2type[ "[object " + name + "]" ] = name.toLowerCase();
1023});
1024
1025browserMatch = jQuery.uaMatch( userAgent );
1026if ( browserMatch.browser ) {
1027	jQuery.browser[ browserMatch.browser ] = true;
1028	jQuery.browser.version = browserMatch.version;
1029}
1030
1031// Deprecated, use jQuery.browser.webkit instead
1032if ( jQuery.browser.webkit ) {
1033	jQuery.browser.safari = true;
1034}
1035
1036if ( indexOf ) {
1037	jQuery.inArray = function( elem, array ) {
1038		return indexOf.call( array, elem );
1039	};
1040}
1041
1042// IE doesn't match non-breaking spaces with \s
1043if ( rnotwhite.test( "\xA0" ) ) {
1044	trimLeft = /^[\s\xA0]+/;
1045	trimRight = /[\s\xA0]+$/;
1046}
1047
1048// All jQuery objects should point back to these
1049rootjQuery = jQuery(document);
1050
1051// Cleanup functions for the document ready method
1052if ( document.addEventListener ) {
1053	DOMContentLoaded = function() {
1054		document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
1055		jQuery.ready();
1056	};
1057
1058} else if ( document.attachEvent ) {
1059	DOMContentLoaded = function() {
1060		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
1061		if ( document.readyState === "complete" ) {
1062			document.detachEvent( "onreadystatechange", DOMContentLoaded );
1063			jQuery.ready();
1064		}
1065	};
1066}
1067
1068// The DOM ready check for Internet Explorer
1069function doScrollCheck() {
1070	if ( jQuery.isReady ) {
1071		return;
1072	}
1073
1074	try {
1075		// If IE is used, use the trick by Diego Perini
1076		// http://javascript.nwbox.com/IEContentLoaded/
1077		document.documentElement.doScroll("left");
1078	} catch(e) {
1079		setTimeout( doScrollCheck, 1 );
1080		return;
1081	}
1082
1083	// and execute any waiting functions
1084	jQuery.ready();
1085}
1086
1087// Expose jQuery to the global object
1088return jQuery;
1089
1090})();
1091
1092
1093(function() {
1094
1095	jQuery.support = {};
1096
1097	var div = document.createElement("div");
1098
1099	div.style.display = "none";
1100	div.innerHTML = "   <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
1101
1102	var all = div.getElementsByTagName("*"),
1103		a = div.getElementsByTagName("a")[0],
1104		select = document.createElement("select"),
1105		opt = select.appendChild( document.createElement("option") ),
1106		input = div.getElementsByTagName("input")[0];
1107
1108	// Can't get basic test support
1109	if ( !all || !all.length || !a ) {
1110		return;
1111	}
1112
1113	jQuery.support = {
1114		// IE strips leading whitespace when .innerHTML is used
1115		leadingWhitespace: div.firstChild.nodeType === 3,
1116
1117		// Make sure that tbody elements aren't automatically inserted
1118		// IE will insert them into empty tables
1119		tbody: !div.getElementsByTagName("tbody").length,
1120
1121		// Make sure that link elements get serialized correctly by innerHTML
1122		// This requires a wrapper element in IE
1123		htmlSerialize: !!div.getElementsByTagName("link").length,
1124
1125		// Get the style information from getAttribute
1126		// (IE uses .cssText insted)
1127		style: /red/.test( a.getAttribute("style") ),
1128
1129		// Make sure that URLs aren't manipulated
1130		// (IE normalizes it by default)
1131		hrefNormalized: a.getAttribute("href") === "/a",
1132
1133		// Make sure that element opacity exists
1134		// (IE uses filter instead)
1135		// Use a regex to work around a WebKit issue. See #5145
1136		opacity: /^0.55$/.test( a.style.opacity ),
1137
1138		// Verify style float existence
1139		// (IE uses styleFloat instead of cssFloat)
1140		cssFloat: !!a.style.cssFloat,
1141
1142		// Make sure that if no value is specified for a checkbox
1143		// that it defaults to "on".
1144		// (WebKit defaults to "" instead)
1145		checkOn: input.value === "on",
1146
1147		// Make sure that a selected-by-default option has a working selected property.
1148		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1149		optSelected: opt.selected,
1150
1151		// Will be defined later
1152		deleteExpando: true,
1153		optDisabled: false,
1154		checkClone: false,
1155		noCloneEvent: true,
1156		noCloneChecked: true,
1157		boxModel: null,
1158		inlineBlockNeedsLayout: false,
1159		shrinkWrapBlocks: false,
1160		reliableHiddenOffsets: true
1161	};
1162
1163	input.checked = true;
1164	jQuery.support.noCloneChecked = input.cloneNode( true ).checked;
1165
1166	// Make sure that the options inside disabled selects aren't marked as disabled
1167	// (WebKit marks them as diabled)
1168	select.disabled = true;
1169	jQuery.support.optDisabled = !opt.disabled;
1170
1171	var _scriptEval = null;
1172	jQuery.support.scriptEval = function() {
1173		if ( _scriptEval === null ) {
1174			var root = document.documentElement,
1175				script = document.createElement("script"),
1176				id = "script" + jQuery.now();
1177
1178			try {
1179				script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
1180			} catch(e) {}
1181
1182			root.insertBefore( script, root.firstChild );
1183
1184			// Make sure that the execution of code works by injecting a script
1185			// tag with appendChild/createTextNode
1186			// (IE doesn't support this, fails, and uses .text instead)
1187			if ( window[ id ] ) {
1188				_scriptEval = true;
1189				delete window[ id ];
1190			} else {
1191				_scriptEval = false;
1192			}
1193
1194			root.removeChild( script );
1195			// release memory in IE
1196			root = script = id  = null;
1197		}
1198
1199		return _scriptEval;
1200	};
1201
1202	// Test to see if it's possible to delete an expando from an element
1203	// Fails in Internet Explorer
1204	try {
1205		delete div.test;
1206
1207	} catch(e) {
1208		jQuery.support.deleteExpando = false;
1209	}
1210
1211	if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1212		div.attachEvent("onclick", function click() {
1213			// Cloning a node shouldn't copy over any
1214			// bound event handlers (IE does this)
1215			jQuery.support.noCloneEvent = false;
1216			div.detachEvent("onclick", click);
1217		});
1218		div.cloneNode(true).fireEvent("onclick");
1219	}
1220
1221	div = document.createElement("div");
1222	div.innerHTML = "<input type='radio' name='radiotest' checked='checked'/>";
1223
1224	var fragment = document.createDocumentFragment();
1225	fragment.appendChild( div.firstChild );
1226
1227	// WebKit doesn't clone checked state correctly in fragments
1228	jQuery.support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
1229
1230	// Figure out if the W3C box model works as expected
1231	// document.body must exist before we can do this
1232	jQuery(function() {
1233		var div = document.createElement("div"),
1234			body = document.getElementsByTagName("body")[0];
1235
1236		// Frameset documents with no body should not run this code
1237		if ( !body ) {
1238			return;
1239		}
1240
1241		div.style.width = div.style.paddingLeft = "1px";
1242		body.appendChild( div );
1243		jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
1244
1245		if ( "zoom" in div.style ) {
1246			// Check if natively block-level elements act like inline-block
1247			// elements when setting their display to 'inline' and giving
1248			// them layout
1249			// (IE < 8 does this)
1250			div.style.display = "inline";
1251			div.style.zoom = 1;
1252			jQuery.support.inlineBlockNeedsLayout = div.offsetWidth === 2;
1253
1254			// Check if elements with layout shrink-wrap their children
1255			// (IE 6 does this)
1256			div.style.display = "";
1257			div.innerHTML = "<div style='width:4px;'></div>";
1258			jQuery.support.shrinkWrapBlocks = div.offsetWidth !== 2;
1259		}
1260
1261		div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
1262		var tds = div.getElementsByTagName("td");
1263
1264		// Check if table cells still have offsetWidth/Height when they are set
1265		// to display:none and there are still other visible table cells in a
1266		// table row; if so, offsetWidth/Height are not reliable for use when
1267		// determining if an element has been hidden directly using
1268		// display:none (it is still safe to use offsets if a parent element is
1269		// hidden; don safety goggles and see bug #4512 for more information).
1270		// (only IE 8 fails this test)
1271		jQuery.support.reliableHiddenOffsets = tds[0].offsetHeight === 0;
1272
1273		tds[0].style.display = "";
1274		tds[1].style.display = "none";
1275
1276		// Check if empty table cells still have offsetWidth/Height
1277		// (IE < 8 fail this test)
1278		jQuery.support.reliableHiddenOffsets = jQuery.support.reliableHiddenOffsets && tds[0].offsetHeight === 0;
1279		div.innerHTML = "";
1280
1281		body.removeChild( div ).style.display = "none";
1282		div = tds = null;
1283	});
1284
1285	// Technique from Juriy Zaytsev
1286	// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
1287	var eventSupported = function( eventName ) {
1288		var el = document.createElement("div");
1289		eventName = "on" + eventName;
1290
1291		// We only care about the case where non-standard event systems
1292		// are used, namely in IE. Short-circuiting here helps us to
1293		// avoid an eval call (in setAttribute) which can cause CSP
1294		// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1295		if ( !el.attachEvent ) {
1296			return true;
1297		}
1298
1299		var isSupported = (eventName in el);
1300		if ( !isSupported ) {
1301			el.setAttribute(eventName, "return;");
1302			isSupported = typeof el[eventName] === "function";
1303		}
1304		el = null;
1305
1306		return isSupported;
1307	};
1308
1309	jQuery.support.submitBubbles = eventSupported("submit");
1310	jQuery.support.changeBubbles = eventSupported("change");
1311
1312	// release memory in IE
1313	div = all = a = null;
1314})();
1315
1316
1317
1318var rbrace = /^(?:\{.*\}|\[.*\])$/;
1319
1320jQuery.extend({
1321	cache: {},
1322
1323	// Please use with caution
1324	uuid: 0,
1325
1326	// Unique for each copy of jQuery on the page
1327	// Non-digits removed to match rinlinejQuery
1328	expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1329
1330	// The following elements throw uncatchable exceptions if you
1331	// attempt to add expando properties to them.
1332	noData: {
1333		"embed": true,
1334		// Ban all objects except for Flash (which handle expandos)
1335		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1336		"applet": true
1337	},
1338
1339	hasData: function( elem ) {
1340		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1341
1342		return !!elem && !isEmptyDataObject( elem );
1343	},
1344
1345	data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1346		if ( !jQuery.acceptData( elem ) ) {
1347			return;
1348		}
1349
1350		var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,
1351
1352			// We have to handle DOM nodes and JS objects differently because IE6-7
1353			// can't GC object references properly across the DOM-JS boundary
1354			isNode = elem.nodeType,
1355
1356			// Only DOM nodes need the global jQuery cache; JS object data is
1357			// attached directly to the object so GC can occur automatically
1358			cache = isNode ? jQuery.cache : elem,
1359
1360			// Only defining an ID for JS objects if its cache already exists allows
1361			// the code to shortcut on the same path as a DOM node with no cache
1362			id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
1363
1364		// Avoid doing any more work than we need to when trying to get data on an
1365		// object that has no data at all
1366		if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
1367			return;
1368		}
1369
1370		if ( !id ) {
1371			// Only DOM nodes need a new unique ID for each element since their data
1372			// ends up in the global cache
1373			if ( isNode ) {
1374				elem[ jQuery.expando ] = id = ++jQuery.uuid;
1375			} else {
1376				id = jQuery.expando;
1377			}
1378		}
1379
1380		if ( !cache[ id ] ) {
1381			cache[ id ] = {};
1382
1383			// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1384			// metadata on plain JS objects when the object is serialized using
1385			// JSON.stringify
1386			if ( !isNode ) {
1387				cache[ id ].toJSON = jQuery.noop;
1388			}
1389		}
1390
1391		// An object can be passed to jQuery.data instead of a key/value pair; this gets
1392		// shallow copied over onto the existing cache
1393		if ( typeof name === "object" || typeof name === "function" ) {
1394			if ( pvt ) {
1395				cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
1396			} else {
1397				cache[ id ] = jQuery.extend(cache[ id ], name);
1398			}
1399		}
1400
1401		thisCache = cache[ id ];
1402
1403		// Internal jQuery data is stored in a separate object inside the object's data
1404		// cache in order to avoid key collisions between internal data and user-defined
1405		// data
1406		if ( pvt ) {
1407			if ( !thisCache[ internalKey ] ) {
1408				thisCache[ internalKey ] = {};
1409			}
1410
1411			thisCache = thisCache[ internalKey ];
1412		}
1413
1414		if ( data !== undefined ) {
1415			thisCache[ name ] = data;
1416		}
1417
1418		// TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
1419		// not attempt to inspect the internal events object using jQuery.data, as this
1420		// internal data object is undocumented and subject to change.
1421		if ( name === "events" && !thisCache[name] ) {
1422			return thisCache[ internalKey ] && thisCache[ internalKey ].events;
1423		}
1424
1425		return getByName ? thisCache[ name ] : thisCache;
1426	},
1427
1428	removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1429		if ( !jQuery.acceptData( elem ) ) {
1430			return;
1431		}
1432
1433		var internalKey = jQuery.expando, isNode = elem.nodeType,
1434
1435			// See jQuery.data for more information
1436			cache = isNode ? jQuery.cache : elem,
1437
1438			// See jQuery.data for more information
1439			id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
1440
1441		// If there is already no cache entry for this object, there is no
1442		// purpose in continuing
1443		if ( !cache[ id ] ) {
1444			return;
1445		}
1446
1447		if ( name ) {
1448			var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
1449
1450			if ( thisCache ) {
1451				delete thisCache[ name ];
1452
1453				// If there is no data left in the cache, we want to continue
1454				// and let the cache object itself get destroyed
1455				if ( !isEmptyDataObject(thisCache) ) {
1456					return;
1457				}
1458			}
1459		}
1460
1461		// See jQuery.data for more information
1462		if ( pvt ) {
1463			delete cache[ id ][ internalKey ];
1464
1465			// Don't destroy the parent cache unless the internal data object
1466			// had been the only thing left in it
1467			if ( !isEmptyDataObject(cache[ id ]) ) {
1468				return;
1469			}
1470		}
1471
1472		var internalCache = cache[ id ][ internalKey ];
1473
1474		// Browsers that fail expando deletion also refuse to delete expandos on
1475		// the window, but it will allow it on all other JS objects; other browsers
1476		// don't care
1477		if ( jQuery.support.deleteExpando || cache != window ) {
1478			delete cache[ id ];
1479		} else {
1480			cache[ id ] = null;
1481		}
1482
1483		// We destroyed the entire user cache at once because it's faster than
1484		// iterating through each key, but we need to continue to persist internal
1485		// data if it existed
1486		if ( internalCache ) {
1487			cache[ id ] = {};
1488			// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1489			// metadata on plain JS objects when the object is serialized using
1490			// JSON.stringify
1491			if ( !isNode ) {
1492				cache[ id ].toJSON = jQuery.noop;
1493			}
1494
1495			cache[ id ][ internalKey ] = internalCache;
1496
1497		// Otherwise, we need to eliminate the expando on the node to avoid
1498		// false lookups in the cache for entries that no longer exist
1499		} else if ( isNode ) {
1500			// IE does not allow us to delete expando properties from nodes,
1501			// nor does it have a removeAttribute function on Document nodes;
1502			// we must handle all of these cases
1503			if ( jQuery.support.deleteExpando ) {
1504				delete elem[ jQuery.expando ];
1505			} else if ( elem.removeAttribute ) {
1506				elem.removeAttribute( jQuery.expando );
1507			} else {
1508				elem[ jQuery.expando ] = null;
1509			}
1510		}
1511	},
1512
1513	// For internal use only.
1514	_data: function( elem, name, data ) {
1515		return jQuery.data( elem, name, data, true );
1516	},
1517
1518	// A method for determining if a DOM node can handle the data expando
1519	acceptData: function( elem ) {
1520		if ( elem.nodeName ) {
1521			var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1522
1523			if ( match ) {
1524				return !(match === true || elem.getAttribute("classid") !== match);
1525			}
1526		}
1527
1528		return true;
1529	}
1530});
1531
1532jQuery.fn.extend({
1533	data: function( key, value ) {
1534		var data = null;
1535
1536		if ( typeof key === "undefined" ) {
1537			if ( this.length ) {
1538				data = jQuery.data( this[0] );
1539
1540				if ( this[0].nodeType === 1 ) {
1541					var attr = this[0].attributes, name;
1542					for ( var i = 0, l = attr.length; i < l; i++ ) {
1543						name = attr[i].name;
1544
1545						if ( name.indexOf( "data-" ) === 0 ) {
1546							name = name.substr( 5 );
1547							dataAttr( this[0], name, data[ name ] );
1548						}
1549					}
1550				}
1551			}
1552
1553			return data;
1554
1555		} else if ( typeof key === "object" ) {
1556			return this.each(function() {
1557				jQuery.data( this, key );
1558			});
1559		}
1560
1561		var parts = key.split(".");
1562		parts[1] = parts[1] ? "." + parts[1] : "";
1563
1564		if ( value === undefined ) {
1565			data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1566
1567			// Try to fetch any internally stored data first
1568			if ( data === undefined && this.length ) {
1569				data = jQuery.data( this[0], key );
1570				data = dataAttr( this[0], key, data );
1571			}
1572
1573			return data === undefined && parts[1] ?
1574				this.data( parts[0] ) :
1575				data;
1576
1577		} else {
1578			return this.each(function() {
1579				var $this = jQuery( this ),
1580					args = [ parts[0], value ];
1581
1582				$this.triggerHandler( "setData" + parts[1] + "!", args );
1583				jQuery.data( this, key, value );
1584				$this.triggerHandler( "changeData" + parts[1] + "!", args );
1585			});
1586		}
1587	},
1588
1589	removeData: function( key ) {
1590		return this.each(function() {
1591			jQuery.removeData( this, key );
1592		});
1593	}
1594});
1595
1596function dataAttr( elem, key, data ) {
1597	// If nothing was found internally, try to fetch any
1598	// data from the HTML5 data-* attribute
1599	if ( data === undefined && elem.nodeType === 1 ) {
1600		data = elem.getAttribute( "data-" + key );
1601
1602		if ( typeof data === "string" ) {
1603			try {
1604				data = data === "true" ? true :
1605				data === "false" ? false :
1606				data === "null" ? null :
1607				!jQuery.isNaN( data ) ? parseFloat( data ) :
1608					rbrace.test( data ) ? jQuery.parseJSON( data ) :
1609					data;
1610			} catch( e ) {}
1611
1612			// Make sure we set the data so it isn't changed later
1613			jQuery.data( elem, key, data );
1614
1615		} else {
1616			data = undefined;
1617		}
1618	}
1619
1620	return data;
1621}
1622
1623// TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
1624// property to be considered empty objects; this property always exists in
1625// order to make sure JSON.stringify does not expose internal metadata
1626function isEmptyDataObject( obj ) {
1627	for ( var name in obj ) {
1628		if ( name !== "toJSON" ) {
1629			return false;
1630		}
1631	}
1632
1633	return true;
1634}
1635
1636
1637
1638
1639jQuery.extend({
1640	queue: function( elem, type, data ) {
1641		if ( !elem ) {
1642			return;
1643		}
1644
1645		type = (type || "fx") + "queue";
1646		var q = jQuery._data( elem, type );
1647
1648		// Speed up dequeue by getting out quickly if this is just a lookup
1649		if ( !data ) {
1650			return q || [];
1651		}
1652
1653		if ( !q || jQuery.isArray(data) ) {
1654			q = jQuery._data( elem, type, jQuery.makeArray(data) );
1655
1656		} else {
1657			q.push( data );
1658		}
1659
1660		return q;
1661	},
1662
1663	dequeue: function( elem, type ) {
1664		type = type || "fx";
1665
1666		var queue = jQuery.queue( elem, type ),
1667			fn = queue.shift();
1668
1669		// If the fx queue is dequeued, always remove the progress sentinel
1670		if ( fn === "inprogress" ) {
1671			fn = queue.shift();
1672		}
1673
1674		if ( fn ) {
1675			// Add a progress sentinel to prevent the fx queue from being
1676			// automatically dequeued
1677			if ( type === "fx" ) {
1678				queue.unshift("inprogress");
1679			}
1680
1681			fn.call(elem, function() {
1682				jQuery.dequeue(elem, type);
1683			});
1684		}
1685
1686		if ( !queue.length ) {
1687			jQuery.removeData( elem, type + "queue", true );
1688		}
1689	}
1690});
1691
1692jQuery.fn.extend({
1693	queue: function( type, data ) {
1694		if ( typeof type !== "string" ) {
1695			data = type;
1696			type = "fx";
1697		}
1698
1699		if ( data === undefined ) {
1700			return jQuery.queue( this[0], type );
1701		}
1702		return this.each(function( i ) {
1703			var queue = jQuery.queue( this, type, data );
1704
1705			if ( type === "fx" && queue[0] !== "inprogress" ) {
1706				jQuery.dequeue( this, type );
1707			}
1708		});
1709	},
1710	dequeue: function( type ) {
1711		return this.each(function() {
1712			jQuery.dequeue( this, type );
1713		});
1714	},
1715
1716	// Based off of the plugin by Clint Helfers, with permission.
1717	// http://blindsignals.com/index.php/2009/07/jquery-delay/
1718	delay: function( time, type ) {
1719		time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1720		type = type || "fx";
1721
1722		return this.queue( type, function() {
1723			var elem = this;
1724			setTimeout(function() {
1725				jQuery.dequeue( elem, type );
1726			}, time );
1727		});
1728	},
1729
1730	clearQueue: function( type ) {
1731		return this.queue( type || "fx", [] );
1732	}
1733});
1734
1735
1736
1737
1738var rclass = /[\n\t\r]/g,
1739	rspaces = /\s+/,
1740	rreturn = /\r/g,
1741	rspecialurl = /^(?:href|src|style)$/,
1742	rtype = /^(?:button|input)$/i,
1743	rfocusable = /^(?:button|input|object|select|textarea)$/i,
1744	rclickable = /^a(?:rea)?$/i,
1745	rradiocheck = /^(?:radio|checkbox)$/i;
1746
1747jQuery.props = {
1748	"for": "htmlFor",
1749	"class": "className",
1750	readonly: "readOnly",
1751	maxlength: "maxLength",
1752	cellspacing: "cellSpacing",
1753	rowspan: "rowSpan",
1754	colspan: "colSpan",
1755	tabindex: "tabIndex",
1756	usemap: "useMap",
1757	frameborder: "frameBorder"
1758};
1759
1760jQuery.fn.extend({
1761	attr: function( name, value ) {
1762		return jQuery.access( this, name, value, true, jQuery.attr );
1763	},
1764
1765	removeAttr: function( name, fn ) {
1766		return this.each(function(){
1767			jQuery.attr( this, name, "" );
1768			if ( this.nodeType === 1 ) {
1769				this.removeAttribute( name );
1770			}
1771		});
1772	},
1773
1774	addClass: function( value ) {
1775		if ( jQuery.isFunction(value) ) {
1776			return this.each(function(i) {
1777				var self = jQuery(this);
1778				self.addClass( value.call(this, i, self.attr("class")) );
1779			});
1780		}
1781
1782		if ( value && typeof value === "string" ) {
1783			var classNames = (value || "").split( rspaces );
1784
1785			for ( var i = 0, l = this.length; i < l; i++ ) {
1786				var elem = this[i];
1787
1788				if ( elem.nodeType === 1 ) {
1789					if ( !elem.className ) {
1790						elem.className = value;
1791
1792					} else {
1793						var className = " " + elem.className + " ",
1794							setClass = elem.className;
1795
1796						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1797							if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
1798								setClass += " " + classNames[c];
1799							}
1800						}
1801						elem.className = jQuery.trim( setClass );
1802					}
1803				}
1804			}
1805		}
1806
1807		return this;
1808	},
1809
1810	removeClass: function( value ) {
1811		if ( jQuery.isFunction(value) ) {
1812			return this.each(function(i) {
1813				var self = jQuery(this);
1814				self.removeClass( value.call(this, i, self.attr("class")) );
1815			});
1816		}
1817
1818		if ( (value && typeof value === "string") || value === undefined ) {
1819			var classNames = (value || "").split( rspaces );
1820
1821			for ( var i = 0, l = this.length; i < l; i++ ) {
1822				var elem = this[i];
1823
1824				if ( elem.nodeType === 1 && elem.className ) {
1825					if ( value ) {
1826						var className = (" " + elem.className + " ").replace(rclass, " ");
1827						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1828							className = className.replace(" " + classNames[c] + " ", " ");
1829						}
1830						elem.className = jQuery.trim( className );
1831
1832					} else {
1833						elem.className = "";
1834					}
1835				}
1836			}
1837		}
1838
1839		return this;
1840	},
1841
1842	toggleClass: function( value, stateVal ) {
1843		var type = typeof value,
1844			isBool = typeof stateVal === "boolean";
1845
1846		if ( jQuery.isFunction( value ) ) {
1847			return this.each(function(i) {
1848				var self = jQuery(this);
1849				self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
1850			});
1851		}
1852
1853		return this.each(function() {
1854			if ( type === "string" ) {
1855				// toggle individual class names
1856				var className,
1857					i = 0,
1858					self = jQuery( this ),
1859					state = stateVal,
1860					classNames = value.split( rspaces );
1861
1862				while ( (className = classNames[ i++ ]) ) {
1863					// check each className given, space seperated list
1864					state = isBool ? state : !self.hasClass( className );
1865					self[ state ? "addClass" : "removeClass" ]( className );
1866				}
1867
1868			} else if ( type === "undefined" || type === "boolean" ) {
1869				if ( this.className ) {
1870					// store className if set
1871					jQuery._data( this, "__className__", this.className );
1872				}
1873
1874				// toggle whole className
1875				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
1876			}
1877		});
1878	},
1879
1880	hasClass: function( selector ) {
1881		var className = " " + selector + " ";
1882		for ( var i = 0, l = this.length; i < l; i++ ) {
1883			if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
1884				return true;
1885			}
1886		}
1887
1888		return false;
1889	},
1890
1891	val: function( value ) {
1892		if ( !arguments.length ) {
1893			var elem = this[0];
1894
1895			if ( elem ) {
1896				if ( jQuery.nodeName( elem, "option" ) ) {
1897					// attributes.value is undefined in Blackberry 4.7 but
1898					// uses .value. See #6932
1899					var val = elem.attributes.value;
1900					return !val || val.specified ? elem.value : elem.text;
1901				}
1902
1903				// We need to handle select boxes special
1904				if ( jQuery.nodeName( elem, "select" ) ) {
1905					var index = elem.selectedIndex,
1906						values = [],
1907						options = elem.options,
1908						one = elem.type === "select-one";
1909
1910					// Nothing was sel…