sawine@5: /*!
sawine@5:  * jQuery JavaScript Library v1.6.4
sawine@5:  * http://jquery.com/
sawine@5:  *
sawine@5:  * Copyright 2011, John Resig
sawine@5:  * Dual licensed under the MIT or GPL Version 2 licenses.
sawine@5:  * http://jquery.org/license
sawine@5:  *
sawine@5:  * Includes Sizzle.js
sawine@5:  * http://sizzlejs.com/
sawine@5:  * Copyright 2011, The Dojo Foundation
sawine@5:  * Released under the MIT, BSD, and GPL Licenses.
sawine@5:  *
sawine@5:  * Date: Mon Sep 12 18:54:48 2011 -0400
sawine@5:  */
sawine@5: (function( window, undefined ) {
sawine@5: 
sawine@5: // Use the correct document accordingly with window argument (sandbox)
sawine@5: var document = window.document,
sawine@5: 	navigator = window.navigator,
sawine@5: 	location = window.location;
sawine@5: var jQuery = (function() {
sawine@5: 
sawine@5: // Define a local copy of jQuery
sawine@5: var jQuery = function( selector, context ) {
sawine@5: 		// The jQuery object is actually just the init constructor 'enhanced'
sawine@5: 		return new jQuery.fn.init( selector, context, rootjQuery );
sawine@5: 	},
sawine@5: 
sawine@5: 	// Map over jQuery in case of overwrite
sawine@5: 	_jQuery = window.jQuery,
sawine@5: 
sawine@5: 	// Map over the $ in case of overwrite
sawine@5: 	_$ = window.$,
sawine@5: 
sawine@5: 	// A central reference to the root jQuery(document)
sawine@5: 	rootjQuery,
sawine@5: 
sawine@5: 	// A simple way to check for HTML strings or ID strings
sawine@5: 	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
sawine@5: 	quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
sawine@5: 
sawine@5: 	// Check if a string has a non-whitespace character in it
sawine@5: 	rnotwhite = /\S/,
sawine@5: 
sawine@5: 	// Used for trimming whitespace
sawine@5: 	trimLeft = /^\s+/,
sawine@5: 	trimRight = /\s+$/,
sawine@5: 
sawine@5: 	// Check for digits
sawine@5: 	rdigit = /\d/,
sawine@5: 
sawine@5: 	// Match a standalone tag
sawine@5: 	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
sawine@5: 
sawine@5: 	// JSON RegExp
sawine@5: 	rvalidchars = /^[\],:{}\s]*$/,
sawine@5: 	rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
sawine@5: 	rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
sawine@5: 	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
sawine@5: 
sawine@5: 	// Useragent RegExp
sawine@5: 	rwebkit = /(webkit)[ \/]([\w.]+)/,
sawine@5: 	ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
sawine@5: 	rmsie = /(msie) ([\w.]+)/,
sawine@5: 	rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
sawine@5: 
sawine@5: 	// Matches dashed string for camelizing
sawine@5: 	rdashAlpha = /-([a-z]|[0-9])/ig,
sawine@5: 	rmsPrefix = /^-ms-/,
sawine@5: 
sawine@5: 	// Used by jQuery.camelCase as callback to replace()
sawine@5: 	fcamelCase = function( all, letter ) {
sawine@5: 		return ( letter + "" ).toUpperCase();
sawine@5: 	},
sawine@5: 
sawine@5: 	// Keep a UserAgent string for use with jQuery.browser
sawine@5: 	userAgent = navigator.userAgent,
sawine@5: 
sawine@5: 	// For matching the engine and version of the browser
sawine@5: 	browserMatch,
sawine@5: 
sawine@5: 	// The deferred used on DOM ready
sawine@5: 	readyList,
sawine@5: 
sawine@5: 	// The ready event handler
sawine@5: 	DOMContentLoaded,
sawine@5: 
sawine@5: 	// Save a reference to some core methods
sawine@5: 	toString = Object.prototype.toString,
sawine@5: 	hasOwn = Object.prototype.hasOwnProperty,
sawine@5: 	push = Array.prototype.push,
sawine@5: 	slice = Array.prototype.slice,
sawine@5: 	trim = String.prototype.trim,
sawine@5: 	indexOf = Array.prototype.indexOf,
sawine@5: 
sawine@5: 	// [[Class]] -> type pairs
sawine@5: 	class2type = {};
sawine@5: 
sawine@5: jQuery.fn = jQuery.prototype = {
sawine@5: 	constructor: jQuery,
sawine@5: 	init: function( selector, context, rootjQuery ) {
sawine@5: 		var match, elem, ret, doc;
sawine@5: 
sawine@5: 		// Handle $(""), $(null), or $(undefined)
sawine@5: 		if ( !selector ) {
sawine@5: 			return this;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Handle $(DOMElement)
sawine@5: 		if ( selector.nodeType ) {
sawine@5: 			this.context = this[0] = selector;
sawine@5: 			this.length = 1;
sawine@5: 			return this;
sawine@5: 		}
sawine@5: 
sawine@5: 		// The body element only exists once, optimize finding it
sawine@5: 		if ( selector === "body" && !context && document.body ) {
sawine@5: 			this.context = document;
sawine@5: 			this[0] = document.body;
sawine@5: 			this.selector = selector;
sawine@5: 			this.length = 1;
sawine@5: 			return this;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Handle HTML strings
sawine@5: 		if ( typeof selector === "string" ) {
sawine@5: 			// Are we dealing with HTML string or an ID?
sawine@5: 			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
sawine@5: 				// Assume that strings that start and end with <> are HTML and skip the regex check
sawine@5: 				match = [ null, selector, null ];
sawine@5: 
sawine@5: 			} else {
sawine@5: 				match = quickExpr.exec( selector );
sawine@5: 			}
sawine@5: 
sawine@5: 			// Verify a match, and that no context was specified for #id
sawine@5: 			if ( match && (match[1] || !context) ) {
sawine@5: 
sawine@5: 				// HANDLE: $(html) -> $(array)
sawine@5: 				if ( match[1] ) {
sawine@5: 					context = context instanceof jQuery ? context[0] : context;
sawine@5: 					doc = (context ? context.ownerDocument || context : document);
sawine@5: 
sawine@5: 					// If a single string is passed in and it's a single tag
sawine@5: 					// just do a createElement and skip the rest
sawine@5: 					ret = rsingleTag.exec( selector );
sawine@5: 
sawine@5: 					if ( ret ) {
sawine@5: 						if ( jQuery.isPlainObject( context ) ) {
sawine@5: 							selector = [ document.createElement( ret[1] ) ];
sawine@5: 							jQuery.fn.attr.call( selector, context, true );
sawine@5: 
sawine@5: 						} else {
sawine@5: 							selector = [ doc.createElement( ret[1] ) ];
sawine@5: 						}
sawine@5: 
sawine@5: 					} else {
sawine@5: 						ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
sawine@5: 						selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
sawine@5: 					}
sawine@5: 
sawine@5: 					return jQuery.merge( this, selector );
sawine@5: 
sawine@5: 				// HANDLE: $("#id")
sawine@5: 				} else {
sawine@5: 					elem = document.getElementById( match[2] );
sawine@5: 
sawine@5: 					// Check parentNode to catch when Blackberry 4.6 returns
sawine@5: 					// nodes that are no longer in the document #6963
sawine@5: 					if ( elem && elem.parentNode ) {
sawine@5: 						// Handle the case where IE and Opera return items
sawine@5: 						// by name instead of ID
sawine@5: 						if ( elem.id !== match[2] ) {
sawine@5: 							return rootjQuery.find( selector );
sawine@5: 						}
sawine@5: 
sawine@5: 						// Otherwise, we inject the element directly into the jQuery object
sawine@5: 						this.length = 1;
sawine@5: 						this[0] = elem;
sawine@5: 					}
sawine@5: 
sawine@5: 					this.context = document;
sawine@5: 					this.selector = selector;
sawine@5: 					return this;
sawine@5: 				}
sawine@5: 
sawine@5: 			// HANDLE: $(expr, $(...))
sawine@5: 			} else if ( !context || context.jquery ) {
sawine@5: 				return (context || rootjQuery).find( selector );
sawine@5: 
sawine@5: 			// HANDLE: $(expr, context)
sawine@5: 			// (which is just equivalent to: $(context).find(expr)
sawine@5: 			} else {
sawine@5: 				return this.constructor( context ).find( selector );
sawine@5: 			}
sawine@5: 
sawine@5: 		// HANDLE: $(function)
sawine@5: 		// Shortcut for document ready
sawine@5: 		} else if ( jQuery.isFunction( selector ) ) {
sawine@5: 			return rootjQuery.ready( selector );
sawine@5: 		}
sawine@5: 
sawine@5: 		if (selector.selector !== undefined) {
sawine@5: 			this.selector = selector.selector;
sawine@5: 			this.context = selector.context;
sawine@5: 		}
sawine@5: 
sawine@5: 		return jQuery.makeArray( selector, this );
sawine@5: 	},
sawine@5: 
sawine@5: 	// Start with an empty selector
sawine@5: 	selector: "",
sawine@5: 
sawine@5: 	// The current version of jQuery being used
sawine@5: 	jquery: "1.6.4",
sawine@5: 
sawine@5: 	// The default length of a jQuery object is 0
sawine@5: 	length: 0,
sawine@5: 
sawine@5: 	// The number of elements contained in the matched element set
sawine@5: 	size: function() {
sawine@5: 		return this.length;
sawine@5: 	},
sawine@5: 
sawine@5: 	toArray: function() {
sawine@5: 		return slice.call( this, 0 );
sawine@5: 	},
sawine@5: 
sawine@5: 	// Get the Nth element in the matched element set OR
sawine@5: 	// Get the whole matched element set as a clean array
sawine@5: 	get: function( num ) {
sawine@5: 		return num == null ?
sawine@5: 
sawine@5: 			// Return a 'clean' array
sawine@5: 			this.toArray() :
sawine@5: 
sawine@5: 			// Return just the object
sawine@5: 			( num < 0 ? this[ this.length + num ] : this[ num ] );
sawine@5: 	},
sawine@5: 
sawine@5: 	// Take an array of elements and push it onto the stack
sawine@5: 	// (returning the new matched element set)
sawine@5: 	pushStack: function( elems, name, selector ) {
sawine@5: 		// Build a new jQuery matched element set
sawine@5: 		var ret = this.constructor();
sawine@5: 
sawine@5: 		if ( jQuery.isArray( elems ) ) {
sawine@5: 			push.apply( ret, elems );
sawine@5: 
sawine@5: 		} else {
sawine@5: 			jQuery.merge( ret, elems );
sawine@5: 		}
sawine@5: 
sawine@5: 		// Add the old object onto the stack (as a reference)
sawine@5: 		ret.prevObject = this;
sawine@5: 
sawine@5: 		ret.context = this.context;
sawine@5: 
sawine@5: 		if ( name === "find" ) {
sawine@5: 			ret.selector = this.selector + (this.selector ? " " : "") + selector;
sawine@5: 		} else if ( name ) {
sawine@5: 			ret.selector = this.selector + "." + name + "(" + selector + ")";
sawine@5: 		}
sawine@5: 
sawine@5: 		// Return the newly-formed element set
sawine@5: 		return ret;
sawine@5: 	},
sawine@5: 
sawine@5: 	// Execute a callback for every element in the matched set.
sawine@5: 	// (You can seed the arguments with an array of args, but this is
sawine@5: 	// only used internally.)
sawine@5: 	each: function( callback, args ) {
sawine@5: 		return jQuery.each( this, callback, args );
sawine@5: 	},
sawine@5: 
sawine@5: 	ready: function( fn ) {
sawine@5: 		// Attach the listeners
sawine@5: 		jQuery.bindReady();
sawine@5: 
sawine@5: 		// Add the callback
sawine@5: 		readyList.done( fn );
sawine@5: 
sawine@5: 		return this;
sawine@5: 	},
sawine@5: 
sawine@5: 	eq: function( i ) {
sawine@5: 		return i === -1 ?
sawine@5: 			this.slice( i ) :
sawine@5: 			this.slice( i, +i + 1 );
sawine@5: 	},
sawine@5: 
sawine@5: 	first: function() {
sawine@5: 		return this.eq( 0 );
sawine@5: 	},
sawine@5: 
sawine@5: 	last: function() {
sawine@5: 		return this.eq( -1 );
sawine@5: 	},
sawine@5: 
sawine@5: 	slice: function() {
sawine@5: 		return this.pushStack( slice.apply( this, arguments ),
sawine@5: 			"slice", slice.call(arguments).join(",") );
sawine@5: 	},
sawine@5: 
sawine@5: 	map: function( callback ) {
sawine@5: 		return this.pushStack( jQuery.map(this, function( elem, i ) {
sawine@5: 			return callback.call( elem, i, elem );
sawine@5: 		}));
sawine@5: 	},
sawine@5: 
sawine@5: 	end: function() {
sawine@5: 		return this.prevObject || this.constructor(null);
sawine@5: 	},
sawine@5: 
sawine@5: 	// For internal use only.
sawine@5: 	// Behaves like an Array's method, not like a jQuery method.
sawine@5: 	push: push,
sawine@5: 	sort: [].sort,
sawine@5: 	splice: [].splice
sawine@5: };
sawine@5: 
sawine@5: // Give the init function the jQuery prototype for later instantiation
sawine@5: jQuery.fn.init.prototype = jQuery.fn;
sawine@5: 
sawine@5: jQuery.extend = jQuery.fn.extend = function() {
sawine@5: 	var options, name, src, copy, copyIsArray, clone,
sawine@5: 		target = arguments[0] || {},
sawine@5: 		i = 1,
sawine@5: 		length = arguments.length,
sawine@5: 		deep = false;
sawine@5: 
sawine@5: 	// Handle a deep copy situation
sawine@5: 	if ( typeof target === "boolean" ) {
sawine@5: 		deep = target;
sawine@5: 		target = arguments[1] || {};
sawine@5: 		// skip the boolean and the target
sawine@5: 		i = 2;
sawine@5: 	}
sawine@5: 
sawine@5: 	// Handle case when target is a string or something (possible in deep copy)
sawine@5: 	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
sawine@5: 		target = {};
sawine@5: 	}
sawine@5: 
sawine@5: 	// extend jQuery itself if only one argument is passed
sawine@5: 	if ( length === i ) {
sawine@5: 		target = this;
sawine@5: 		--i;
sawine@5: 	}
sawine@5: 
sawine@5: 	for ( ; i < length; i++ ) {
sawine@5: 		// Only deal with non-null/undefined values
sawine@5: 		if ( (options = arguments[ i ]) != null ) {
sawine@5: 			// Extend the base object
sawine@5: 			for ( name in options ) {
sawine@5: 				src = target[ name ];
sawine@5: 				copy = options[ name ];
sawine@5: 
sawine@5: 				// Prevent never-ending loop
sawine@5: 				if ( target === copy ) {
sawine@5: 					continue;
sawine@5: 				}
sawine@5: 
sawine@5: 				// Recurse if we're merging plain objects or arrays
sawine@5: 				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
sawine@5: 					if ( copyIsArray ) {
sawine@5: 						copyIsArray = false;
sawine@5: 						clone = src && jQuery.isArray(src) ? src : [];
sawine@5: 
sawine@5: 					} else {
sawine@5: 						clone = src && jQuery.isPlainObject(src) ? src : {};
sawine@5: 					}
sawine@5: 
sawine@5: 					// Never move original objects, clone them
sawine@5: 					target[ name ] = jQuery.extend( deep, clone, copy );
sawine@5: 
sawine@5: 				// Don't bring in undefined values
sawine@5: 				} else if ( copy !== undefined ) {
sawine@5: 					target[ name ] = copy;
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	// Return the modified object
sawine@5: 	return target;
sawine@5: };
sawine@5: 
sawine@5: jQuery.extend({
sawine@5: 	noConflict: function( deep ) {
sawine@5: 		if ( window.$ === jQuery ) {
sawine@5: 			window.$ = _$;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( deep && window.jQuery === jQuery ) {
sawine@5: 			window.jQuery = _jQuery;
sawine@5: 		}
sawine@5: 
sawine@5: 		return jQuery;
sawine@5: 	},
sawine@5: 
sawine@5: 	// Is the DOM ready to be used? Set to true once it occurs.
sawine@5: 	isReady: false,
sawine@5: 
sawine@5: 	// A counter to track how many items to wait for before
sawine@5: 	// the ready event fires. See #6781
sawine@5: 	readyWait: 1,
sawine@5: 
sawine@5: 	// Hold (or release) the ready event
sawine@5: 	holdReady: function( hold ) {
sawine@5: 		if ( hold ) {
sawine@5: 			jQuery.readyWait++;
sawine@5: 		} else {
sawine@5: 			jQuery.ready( true );
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	// Handle when the DOM is ready
sawine@5: 	ready: function( wait ) {
sawine@5: 		// Either a released hold or an DOMready/load event and not yet ready
sawine@5: 		if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
sawine@5: 			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
sawine@5: 			if ( !document.body ) {
sawine@5: 				return setTimeout( jQuery.ready, 1 );
sawine@5: 			}
sawine@5: 
sawine@5: 			// Remember that the DOM is ready
sawine@5: 			jQuery.isReady = true;
sawine@5: 
sawine@5: 			// If a normal DOM Ready event fired, decrement, and wait if need be
sawine@5: 			if ( wait !== true && --jQuery.readyWait > 0 ) {
sawine@5: 				return;
sawine@5: 			}
sawine@5: 
sawine@5: 			// If there are functions bound, to execute
sawine@5: 			readyList.resolveWith( document, [ jQuery ] );
sawine@5: 
sawine@5: 			// Trigger any bound ready events
sawine@5: 			if ( jQuery.fn.trigger ) {
sawine@5: 				jQuery( document ).trigger( "ready" ).unbind( "ready" );
sawine@5: 			}
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	bindReady: function() {
sawine@5: 		if ( readyList ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		readyList = jQuery._Deferred();
sawine@5: 
sawine@5: 		// Catch cases where $(document).ready() is called after the
sawine@5: 		// browser event has already occurred.
sawine@5: 		if ( document.readyState === "complete" ) {
sawine@5: 			// Handle it asynchronously to allow scripts the opportunity to delay ready
sawine@5: 			return setTimeout( jQuery.ready, 1 );
sawine@5: 		}
sawine@5: 
sawine@5: 		// Mozilla, Opera and webkit nightlies currently support this event
sawine@5: 		if ( document.addEventListener ) {
sawine@5: 			// Use the handy event callback
sawine@5: 			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
sawine@5: 
sawine@5: 			// A fallback to window.onload, that will always work
sawine@5: 			window.addEventListener( "load", jQuery.ready, false );
sawine@5: 
sawine@5: 		// If IE event model is used
sawine@5: 		} else if ( document.attachEvent ) {
sawine@5: 			// ensure firing before onload,
sawine@5: 			// maybe late but safe also for iframes
sawine@5: 			document.attachEvent( "onreadystatechange", DOMContentLoaded );
sawine@5: 
sawine@5: 			// A fallback to window.onload, that will always work
sawine@5: 			window.attachEvent( "onload", jQuery.ready );
sawine@5: 
sawine@5: 			// If IE and not a frame
sawine@5: 			// continually check to see if the document is ready
sawine@5: 			var toplevel = false;
sawine@5: 
sawine@5: 			try {
sawine@5: 				toplevel = window.frameElement == null;
sawine@5: 			} catch(e) {}
sawine@5: 
sawine@5: 			if ( document.documentElement.doScroll && toplevel ) {
sawine@5: 				doScrollCheck();
sawine@5: 			}
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	// See test/unit/core.js for details concerning isFunction.
sawine@5: 	// Since version 1.3, DOM methods and functions like alert
sawine@5: 	// aren't supported. They return false on IE (#2968).
sawine@5: 	isFunction: function( obj ) {
sawine@5: 		return jQuery.type(obj) === "function";
sawine@5: 	},
sawine@5: 
sawine@5: 	isArray: Array.isArray || function( obj ) {
sawine@5: 		return jQuery.type(obj) === "array";
sawine@5: 	},
sawine@5: 
sawine@5: 	// A crude way of determining if an object is a window
sawine@5: 	isWindow: function( obj ) {
sawine@5: 		return obj && typeof obj === "object" && "setInterval" in obj;
sawine@5: 	},
sawine@5: 
sawine@5: 	isNaN: function( obj ) {
sawine@5: 		return obj == null || !rdigit.test( obj ) || isNaN( obj );
sawine@5: 	},
sawine@5: 
sawine@5: 	type: function( obj ) {
sawine@5: 		return obj == null ?
sawine@5: 			String( obj ) :
sawine@5: 			class2type[ toString.call(obj) ] || "object";
sawine@5: 	},
sawine@5: 
sawine@5: 	isPlainObject: function( obj ) {
sawine@5: 		// Must be an Object.
sawine@5: 		// Because of IE, we also have to check the presence of the constructor property.
sawine@5: 		// Make sure that DOM nodes and window objects don't pass through, as well
sawine@5: 		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
sawine@5: 			return false;
sawine@5: 		}
sawine@5: 
sawine@5: 		try {
sawine@5: 			// Not own constructor property must be Object
sawine@5: 			if ( obj.constructor &&
sawine@5: 				!hasOwn.call(obj, "constructor") &&
sawine@5: 				!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
sawine@5: 				return false;
sawine@5: 			}
sawine@5: 		} catch ( e ) {
sawine@5: 			// IE8,9 Will throw exceptions on certain host objects #9897
sawine@5: 			return false;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Own properties are enumerated firstly, so to speed up,
sawine@5: 		// if last one is own, then all properties are own.
sawine@5: 
sawine@5: 		var key;
sawine@5: 		for ( key in obj ) {}
sawine@5: 
sawine@5: 		return key === undefined || hasOwn.call( obj, key );
sawine@5: 	},
sawine@5: 
sawine@5: 	isEmptyObject: function( obj ) {
sawine@5: 		for ( var name in obj ) {
sawine@5: 			return false;
sawine@5: 		}
sawine@5: 		return true;
sawine@5: 	},
sawine@5: 
sawine@5: 	error: function( msg ) {
sawine@5: 		throw msg;
sawine@5: 	},
sawine@5: 
sawine@5: 	parseJSON: function( data ) {
sawine@5: 		if ( typeof data !== "string" || !data ) {
sawine@5: 			return null;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Make sure leading/trailing whitespace is removed (IE can't handle it)
sawine@5: 		data = jQuery.trim( data );
sawine@5: 
sawine@5: 		// Attempt to parse using the native JSON parser first
sawine@5: 		if ( window.JSON && window.JSON.parse ) {
sawine@5: 			return window.JSON.parse( data );
sawine@5: 		}
sawine@5: 
sawine@5: 		// Make sure the incoming data is actual JSON
sawine@5: 		// Logic borrowed from http://json.org/json2.js
sawine@5: 		if ( rvalidchars.test( data.replace( rvalidescape, "@" )
sawine@5: 			.replace( rvalidtokens, "]" )
sawine@5: 			.replace( rvalidbraces, "")) ) {
sawine@5: 
sawine@5: 			return (new Function( "return " + data ))();
sawine@5: 
sawine@5: 		}
sawine@5: 		jQuery.error( "Invalid JSON: " + data );
sawine@5: 	},
sawine@5: 
sawine@5: 	// Cross-browser xml parsing
sawine@5: 	parseXML: function( data ) {
sawine@5: 		var xml, tmp;
sawine@5: 		try {
sawine@5: 			if ( window.DOMParser ) { // Standard
sawine@5: 				tmp = new DOMParser();
sawine@5: 				xml = tmp.parseFromString( data , "text/xml" );
sawine@5: 			} else { // IE
sawine@5: 				xml = new ActiveXObject( "Microsoft.XMLDOM" );
sawine@5: 				xml.async = "false";
sawine@5: 				xml.loadXML( data );
sawine@5: 			}
sawine@5: 		} catch( e ) {
sawine@5: 			xml = undefined;
sawine@5: 		}
sawine@5: 		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
sawine@5: 			jQuery.error( "Invalid XML: " + data );
sawine@5: 		}
sawine@5: 		return xml;
sawine@5: 	},
sawine@5: 
sawine@5: 	noop: function() {},
sawine@5: 
sawine@5: 	// Evaluates a script in a global context
sawine@5: 	// Workarounds based on findings by Jim Driscoll
sawine@5: 	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
sawine@5: 	globalEval: function( data ) {
sawine@5: 		if ( data && rnotwhite.test( data ) ) {
sawine@5: 			// We use execScript on Internet Explorer
sawine@5: 			// We use an anonymous function so that context is window
sawine@5: 			// rather than jQuery in Firefox
sawine@5: 			( window.execScript || function( data ) {
sawine@5: 				window[ "eval" ].call( window, data );
sawine@5: 			} )( data );
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	// Convert dashed to camelCase; used by the css and data modules
sawine@5: 	// Microsoft forgot to hump their vendor prefix (#9572)
sawine@5: 	camelCase: function( string ) {
sawine@5: 		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
sawine@5: 	},
sawine@5: 
sawine@5: 	nodeName: function( elem, name ) {
sawine@5: 		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
sawine@5: 	},
sawine@5: 
sawine@5: 	// args is for internal usage only
sawine@5: 	each: function( object, callback, args ) {
sawine@5: 		var name, i = 0,
sawine@5: 			length = object.length,
sawine@5: 			isObj = length === undefined || jQuery.isFunction( object );
sawine@5: 
sawine@5: 		if ( args ) {
sawine@5: 			if ( isObj ) {
sawine@5: 				for ( name in object ) {
sawine@5: 					if ( callback.apply( object[ name ], args ) === false ) {
sawine@5: 						break;
sawine@5: 					}
sawine@5: 				}
sawine@5: 			} else {
sawine@5: 				for ( ; i < length; ) {
sawine@5: 					if ( callback.apply( object[ i++ ], args ) === false ) {
sawine@5: 						break;
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 		// A special, fast, case for the most common use of each
sawine@5: 		} else {
sawine@5: 			if ( isObj ) {
sawine@5: 				for ( name in object ) {
sawine@5: 					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
sawine@5: 						break;
sawine@5: 					}
sawine@5: 				}
sawine@5: 			} else {
sawine@5: 				for ( ; i < length; ) {
sawine@5: 					if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
sawine@5: 						break;
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return object;
sawine@5: 	},
sawine@5: 
sawine@5: 	// Use native String.trim function wherever possible
sawine@5: 	trim: trim ?
sawine@5: 		function( text ) {
sawine@5: 			return text == null ?
sawine@5: 				"" :
sawine@5: 				trim.call( text );
sawine@5: 		} :
sawine@5: 
sawine@5: 		// Otherwise use our own trimming functionality
sawine@5: 		function( text ) {
sawine@5: 			return text == null ?
sawine@5: 				"" :
sawine@5: 				text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
sawine@5: 		},
sawine@5: 
sawine@5: 	// results is for internal usage only
sawine@5: 	makeArray: function( array, results ) {
sawine@5: 		var ret = results || [];
sawine@5: 
sawine@5: 		if ( array != null ) {
sawine@5: 			// The window, strings (and functions) also have 'length'
sawine@5: 			// The extra typeof function check is to prevent crashes
sawine@5: 			// in Safari 2 (See: #3039)
sawine@5: 			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
sawine@5: 			var type = jQuery.type( array );
sawine@5: 
sawine@5: 			if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
sawine@5: 				push.call( ret, array );
sawine@5: 			} else {
sawine@5: 				jQuery.merge( ret, array );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return ret;
sawine@5: 	},
sawine@5: 
sawine@5: 	inArray: function( elem, array ) {
sawine@5: 		if ( !array ) {
sawine@5: 			return -1;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( indexOf ) {
sawine@5: 			return indexOf.call( array, elem );
sawine@5: 		}
sawine@5: 
sawine@5: 		for ( var i = 0, length = array.length; i < length; i++ ) {
sawine@5: 			if ( array[ i ] === elem ) {
sawine@5: 				return i;
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return -1;
sawine@5: 	},
sawine@5: 
sawine@5: 	merge: function( first, second ) {
sawine@5: 		var i = first.length,
sawine@5: 			j = 0;
sawine@5: 
sawine@5: 		if ( typeof second.length === "number" ) {
sawine@5: 			for ( var l = second.length; j < l; j++ ) {
sawine@5: 				first[ i++ ] = second[ j ];
sawine@5: 			}
sawine@5: 
sawine@5: 		} else {
sawine@5: 			while ( second[j] !== undefined ) {
sawine@5: 				first[ i++ ] = second[ j++ ];
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		first.length = i;
sawine@5: 
sawine@5: 		return first;
sawine@5: 	},
sawine@5: 
sawine@5: 	grep: function( elems, callback, inv ) {
sawine@5: 		var ret = [], retVal;
sawine@5: 		inv = !!inv;
sawine@5: 
sawine@5: 		// Go through the array, only saving the items
sawine@5: 		// that pass the validator function
sawine@5: 		for ( var i = 0, length = elems.length; i < length; i++ ) {
sawine@5: 			retVal = !!callback( elems[ i ], i );
sawine@5: 			if ( inv !== retVal ) {
sawine@5: 				ret.push( elems[ i ] );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return ret;
sawine@5: 	},
sawine@5: 
sawine@5: 	// arg is for internal usage only
sawine@5: 	map: function( elems, callback, arg ) {
sawine@5: 		var value, key, ret = [],
sawine@5: 			i = 0,
sawine@5: 			length = elems.length,
sawine@5: 			// jquery objects are treated as arrays
sawine@5: 			isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
sawine@5: 
sawine@5: 		// Go through the array, translating each of the items to their
sawine@5: 		if ( isArray ) {
sawine@5: 			for ( ; i < length; i++ ) {
sawine@5: 				value = callback( elems[ i ], i, arg );
sawine@5: 
sawine@5: 				if ( value != null ) {
sawine@5: 					ret[ ret.length ] = value;
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 		// Go through every key on the object,
sawine@5: 		} else {
sawine@5: 			for ( key in elems ) {
sawine@5: 				value = callback( elems[ key ], key, arg );
sawine@5: 
sawine@5: 				if ( value != null ) {
sawine@5: 					ret[ ret.length ] = value;
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		// Flatten any nested arrays
sawine@5: 		return ret.concat.apply( [], ret );
sawine@5: 	},
sawine@5: 
sawine@5: 	// A global GUID counter for objects
sawine@5: 	guid: 1,
sawine@5: 
sawine@5: 	// Bind a function to a context, optionally partially applying any
sawine@5: 	// arguments.
sawine@5: 	proxy: function( fn, context ) {
sawine@5: 		if ( typeof context === "string" ) {
sawine@5: 			var tmp = fn[ context ];
sawine@5: 			context = fn;
sawine@5: 			fn = tmp;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Quick check to determine if target is callable, in the spec
sawine@5: 		// this throws a TypeError, but we will just return undefined.
sawine@5: 		if ( !jQuery.isFunction( fn ) ) {
sawine@5: 			return undefined;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Simulated bind
sawine@5: 		var args = slice.call( arguments, 2 ),
sawine@5: 			proxy = function() {
sawine@5: 				return fn.apply( context, args.concat( slice.call( arguments ) ) );
sawine@5: 			};
sawine@5: 
sawine@5: 		// Set the guid of unique handler to the same of original handler, so it can be removed
sawine@5: 		proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
sawine@5: 
sawine@5: 		return proxy;
sawine@5: 	},
sawine@5: 
sawine@5: 	// Mutifunctional method to get and set values to a collection
sawine@5: 	// The value/s can optionally be executed if it's a function
sawine@5: 	access: function( elems, key, value, exec, fn, pass ) {
sawine@5: 		var length = elems.length;
sawine@5: 
sawine@5: 		// Setting many attributes
sawine@5: 		if ( typeof key === "object" ) {
sawine@5: 			for ( var k in key ) {
sawine@5: 				jQuery.access( elems, k, key[k], exec, fn, value );
sawine@5: 			}
sawine@5: 			return elems;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Setting one attribute
sawine@5: 		if ( value !== undefined ) {
sawine@5: 			// Optionally, function values get executed if exec is true
sawine@5: 			exec = !pass && exec && jQuery.isFunction(value);
sawine@5: 
sawine@5: 			for ( var i = 0; i < length; i++ ) {
sawine@5: 				fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
sawine@5: 			}
sawine@5: 
sawine@5: 			return elems;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Getting an attribute
sawine@5: 		return length ? fn( elems[0], key ) : undefined;
sawine@5: 	},
sawine@5: 
sawine@5: 	now: function() {
sawine@5: 		return (new Date()).getTime();
sawine@5: 	},
sawine@5: 
sawine@5: 	// Use of jQuery.browser is frowned upon.
sawine@5: 	// More details: http://docs.jquery.com/Utilities/jQuery.browser
sawine@5: 	uaMatch: function( ua ) {
sawine@5: 		ua = ua.toLowerCase();
sawine@5: 
sawine@5: 		var match = rwebkit.exec( ua ) ||
sawine@5: 			ropera.exec( ua ) ||
sawine@5: 			rmsie.exec( ua ) ||
sawine@5: 			ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
sawine@5: 			[];
sawine@5: 
sawine@5: 		return { browser: match[1] || "", version: match[2] || "0" };
sawine@5: 	},
sawine@5: 
sawine@5: 	sub: function() {
sawine@5: 		function jQuerySub( selector, context ) {
sawine@5: 			return new jQuerySub.fn.init( selector, context );
sawine@5: 		}
sawine@5: 		jQuery.extend( true, jQuerySub, this );
sawine@5: 		jQuerySub.superclass = this;
sawine@5: 		jQuerySub.fn = jQuerySub.prototype = this();
sawine@5: 		jQuerySub.fn.constructor = jQuerySub;
sawine@5: 		jQuerySub.sub = this.sub;
sawine@5: 		jQuerySub.fn.init = function init( selector, context ) {
sawine@5: 			if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
sawine@5: 				context = jQuerySub( context );
sawine@5: 			}
sawine@5: 
sawine@5: 			return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
sawine@5: 		};
sawine@5: 		jQuerySub.fn.init.prototype = jQuerySub.fn;
sawine@5: 		var rootjQuerySub = jQuerySub(document);
sawine@5: 		return jQuerySub;
sawine@5: 	},
sawine@5: 
sawine@5: 	browser: {}
sawine@5: });
sawine@5: 
sawine@5: // Populate the class2type map
sawine@5: jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
sawine@5: 	class2type[ "[object " + name + "]" ] = name.toLowerCase();
sawine@5: });
sawine@5: 
sawine@5: browserMatch = jQuery.uaMatch( userAgent );
sawine@5: if ( browserMatch.browser ) {
sawine@5: 	jQuery.browser[ browserMatch.browser ] = true;
sawine@5: 	jQuery.browser.version = browserMatch.version;
sawine@5: }
sawine@5: 
sawine@5: // Deprecated, use jQuery.browser.webkit instead
sawine@5: if ( jQuery.browser.webkit ) {
sawine@5: 	jQuery.browser.safari = true;
sawine@5: }
sawine@5: 
sawine@5: // IE doesn't match non-breaking spaces with \s
sawine@5: if ( rnotwhite.test( "\xA0" ) ) {
sawine@5: 	trimLeft = /^[\s\xA0]+/;
sawine@5: 	trimRight = /[\s\xA0]+$/;
sawine@5: }
sawine@5: 
sawine@5: // All jQuery objects should point back to these
sawine@5: rootjQuery = jQuery(document);
sawine@5: 
sawine@5: // Cleanup functions for the document ready method
sawine@5: if ( document.addEventListener ) {
sawine@5: 	DOMContentLoaded = function() {
sawine@5: 		document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
sawine@5: 		jQuery.ready();
sawine@5: 	};
sawine@5: 
sawine@5: } else if ( document.attachEvent ) {
sawine@5: 	DOMContentLoaded = function() {
sawine@5: 		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
sawine@5: 		if ( document.readyState === "complete" ) {
sawine@5: 			document.detachEvent( "onreadystatechange", DOMContentLoaded );
sawine@5: 			jQuery.ready();
sawine@5: 		}
sawine@5: 	};
sawine@5: }
sawine@5: 
sawine@5: // The DOM ready check for Internet Explorer
sawine@5: function doScrollCheck() {
sawine@5: 	if ( jQuery.isReady ) {
sawine@5: 		return;
sawine@5: 	}
sawine@5: 
sawine@5: 	try {
sawine@5: 		// If IE is used, use the trick by Diego Perini
sawine@5: 		// http://javascript.nwbox.com/IEContentLoaded/
sawine@5: 		document.documentElement.doScroll("left");
sawine@5: 	} catch(e) {
sawine@5: 		setTimeout( doScrollCheck, 1 );
sawine@5: 		return;
sawine@5: 	}
sawine@5: 
sawine@5: 	// and execute any waiting functions
sawine@5: 	jQuery.ready();
sawine@5: }
sawine@5: 
sawine@5: return jQuery;
sawine@5: 
sawine@5: })();
sawine@5: 
sawine@5: 
sawine@5: var // Promise methods
sawine@5: 	promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ),
sawine@5: 	// Static reference to slice
sawine@5: 	sliceDeferred = [].slice;
sawine@5: 
sawine@5: jQuery.extend({
sawine@5: 	// Create a simple deferred (one callbacks list)
sawine@5: 	_Deferred: function() {
sawine@5: 		var // callbacks list
sawine@5: 			callbacks = [],
sawine@5: 			// stored [ context , args ]
sawine@5: 			fired,
sawine@5: 			// to avoid firing when already doing so
sawine@5: 			firing,
sawine@5: 			// flag to know if the deferred has been cancelled
sawine@5: 			cancelled,
sawine@5: 			// the deferred itself
sawine@5: 			deferred  = {
sawine@5: 
sawine@5: 				// done( f1, f2, ...)
sawine@5: 				done: function() {
sawine@5: 					if ( !cancelled ) {
sawine@5: 						var args = arguments,
sawine@5: 							i,
sawine@5: 							length,
sawine@5: 							elem,
sawine@5: 							type,
sawine@5: 							_fired;
sawine@5: 						if ( fired ) {
sawine@5: 							_fired = fired;
sawine@5: 							fired = 0;
sawine@5: 						}
sawine@5: 						for ( i = 0, length = args.length; i < length; i++ ) {
sawine@5: 							elem = args[ i ];
sawine@5: 							type = jQuery.type( elem );
sawine@5: 							if ( type === "array" ) {
sawine@5: 								deferred.done.apply( deferred, elem );
sawine@5: 							} else if ( type === "function" ) {
sawine@5: 								callbacks.push( elem );
sawine@5: 							}
sawine@5: 						}
sawine@5: 						if ( _fired ) {
sawine@5: 							deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
sawine@5: 						}
sawine@5: 					}
sawine@5: 					return this;
sawine@5: 				},
sawine@5: 
sawine@5: 				// resolve with given context and args
sawine@5: 				resolveWith: function( context, args ) {
sawine@5: 					if ( !cancelled && !fired && !firing ) {
sawine@5: 						// make sure args are available (#8421)
sawine@5: 						args = args || [];
sawine@5: 						firing = 1;
sawine@5: 						try {
sawine@5: 							while( callbacks[ 0 ] ) {
sawine@5: 								callbacks.shift().apply( context, args );
sawine@5: 							}
sawine@5: 						}
sawine@5: 						finally {
sawine@5: 							fired = [ context, args ];
sawine@5: 							firing = 0;
sawine@5: 						}
sawine@5: 					}
sawine@5: 					return this;
sawine@5: 				},
sawine@5: 
sawine@5: 				// resolve with this as context and given arguments
sawine@5: 				resolve: function() {
sawine@5: 					deferred.resolveWith( this, arguments );
sawine@5: 					return this;
sawine@5: 				},
sawine@5: 
sawine@5: 				// Has this deferred been resolved?
sawine@5: 				isResolved: function() {
sawine@5: 					return !!( firing || fired );
sawine@5: 				},
sawine@5: 
sawine@5: 				// Cancel
sawine@5: 				cancel: function() {
sawine@5: 					cancelled = 1;
sawine@5: 					callbacks = [];
sawine@5: 					return this;
sawine@5: 				}
sawine@5: 			};
sawine@5: 
sawine@5: 		return deferred;
sawine@5: 	},
sawine@5: 
sawine@5: 	// Full fledged deferred (two callbacks list)
sawine@5: 	Deferred: function( func ) {
sawine@5: 		var deferred = jQuery._Deferred(),
sawine@5: 			failDeferred = jQuery._Deferred(),
sawine@5: 			promise;
sawine@5: 		// Add errorDeferred methods, then and promise
sawine@5: 		jQuery.extend( deferred, {
sawine@5: 			then: function( doneCallbacks, failCallbacks ) {
sawine@5: 				deferred.done( doneCallbacks ).fail( failCallbacks );
sawine@5: 				return this;
sawine@5: 			},
sawine@5: 			always: function() {
sawine@5: 				return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments );
sawine@5: 			},
sawine@5: 			fail: failDeferred.done,
sawine@5: 			rejectWith: failDeferred.resolveWith,
sawine@5: 			reject: failDeferred.resolve,
sawine@5: 			isRejected: failDeferred.isResolved,
sawine@5: 			pipe: function( fnDone, fnFail ) {
sawine@5: 				return jQuery.Deferred(function( newDefer ) {
sawine@5: 					jQuery.each( {
sawine@5: 						done: [ fnDone, "resolve" ],
sawine@5: 						fail: [ fnFail, "reject" ]
sawine@5: 					}, function( handler, data ) {
sawine@5: 						var fn = data[ 0 ],
sawine@5: 							action = data[ 1 ],
sawine@5: 							returned;
sawine@5: 						if ( jQuery.isFunction( fn ) ) {
sawine@5: 							deferred[ handler ](function() {
sawine@5: 								returned = fn.apply( this, arguments );
sawine@5: 								if ( returned && jQuery.isFunction( returned.promise ) ) {
sawine@5: 									returned.promise().then( newDefer.resolve, newDefer.reject );
sawine@5: 								} else {
sawine@5: 									newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
sawine@5: 								}
sawine@5: 							});
sawine@5: 						} else {
sawine@5: 							deferred[ handler ]( newDefer[ action ] );
sawine@5: 						}
sawine@5: 					});
sawine@5: 				}).promise();
sawine@5: 			},
sawine@5: 			// Get a promise for this deferred
sawine@5: 			// If obj is provided, the promise aspect is added to the object
sawine@5: 			promise: function( obj ) {
sawine@5: 				if ( obj == null ) {
sawine@5: 					if ( promise ) {
sawine@5: 						return promise;
sawine@5: 					}
sawine@5: 					promise = obj = {};
sawine@5: 				}
sawine@5: 				var i = promiseMethods.length;
sawine@5: 				while( i-- ) {
sawine@5: 					obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
sawine@5: 				}
sawine@5: 				return obj;
sawine@5: 			}
sawine@5: 		});
sawine@5: 		// Make sure only one callback list will be used
sawine@5: 		deferred.done( failDeferred.cancel ).fail( deferred.cancel );
sawine@5: 		// Unexpose cancel
sawine@5: 		delete deferred.cancel;
sawine@5: 		// Call given func if any
sawine@5: 		if ( func ) {
sawine@5: 			func.call( deferred, deferred );
sawine@5: 		}
sawine@5: 		return deferred;
sawine@5: 	},
sawine@5: 
sawine@5: 	// Deferred helper
sawine@5: 	when: function( firstParam ) {
sawine@5: 		var args = arguments,
sawine@5: 			i = 0,
sawine@5: 			length = args.length,
sawine@5: 			count = length,
sawine@5: 			deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
sawine@5: 				firstParam :
sawine@5: 				jQuery.Deferred();
sawine@5: 		function resolveFunc( i ) {
sawine@5: 			return function( value ) {
sawine@5: 				args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
sawine@5: 				if ( !( --count ) ) {
sawine@5: 					// Strange bug in FF4:
sawine@5: 					// Values changed onto the arguments object sometimes end up as undefined values
sawine@5: 					// outside the $.when method. Cloning the object into a fresh array solves the issue
sawine@5: 					deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) );
sawine@5: 				}
sawine@5: 			};
sawine@5: 		}
sawine@5: 		if ( length > 1 ) {
sawine@5: 			for( ; i < length; i++ ) {
sawine@5: 				if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) {
sawine@5: 					args[ i ].promise().then( resolveFunc(i), deferred.reject );
sawine@5: 				} else {
sawine@5: 					--count;
sawine@5: 				}
sawine@5: 			}
sawine@5: 			if ( !count ) {
sawine@5: 				deferred.resolveWith( deferred, args );
sawine@5: 			}
sawine@5: 		} else if ( deferred !== firstParam ) {
sawine@5: 			deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
sawine@5: 		}
sawine@5: 		return deferred.promise();
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: jQuery.support = (function() {
sawine@5: 
sawine@5: 	var div = document.createElement( "div" ),
sawine@5: 		documentElement = document.documentElement,
sawine@5: 		all,
sawine@5: 		a,
sawine@5: 		select,
sawine@5: 		opt,
sawine@5: 		input,
sawine@5: 		marginDiv,
sawine@5: 		support,
sawine@5: 		fragment,
sawine@5: 		body,
sawine@5: 		testElementParent,
sawine@5: 		testElement,
sawine@5: 		testElementStyle,
sawine@5: 		tds,
sawine@5: 		events,
sawine@5: 		eventName,
sawine@5: 		i,
sawine@5: 		isSupported;
sawine@5: 
sawine@5: 	// Preliminary tests
sawine@5: 	div.setAttribute("className", "t");
sawine@5: 	div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
sawine@5: 
sawine@5: 
sawine@5: 	all = div.getElementsByTagName( "*" );
sawine@5: 	a = div.getElementsByTagName( "a" )[ 0 ];
sawine@5: 
sawine@5: 	// Can't get basic test support
sawine@5: 	if ( !all || !all.length || !a ) {
sawine@5: 		return {};
sawine@5: 	}
sawine@5: 
sawine@5: 	// First batch of supports tests
sawine@5: 	select = document.createElement( "select" );
sawine@5: 	opt = select.appendChild( document.createElement("option") );
sawine@5: 	input = div.getElementsByTagName( "input" )[ 0 ];
sawine@5: 
sawine@5: 	support = {
sawine@5: 		// IE strips leading whitespace when .innerHTML is used
sawine@5: 		leadingWhitespace: ( div.firstChild.nodeType === 3 ),
sawine@5: 
sawine@5: 		// Make sure that tbody elements aren't automatically inserted
sawine@5: 		// IE will insert them into empty tables
sawine@5: 		tbody: !div.getElementsByTagName( "tbody" ).length,
sawine@5: 
sawine@5: 		// Make sure that link elements get serialized correctly by innerHTML
sawine@5: 		// This requires a wrapper element in IE
sawine@5: 		htmlSerialize: !!div.getElementsByTagName( "link" ).length,
sawine@5: 
sawine@5: 		// Get the style information from getAttribute
sawine@5: 		// (IE uses .cssText instead)
sawine@5: 		style: /top/.test( a.getAttribute("style") ),
sawine@5: 
sawine@5: 		// Make sure that URLs aren't manipulated
sawine@5: 		// (IE normalizes it by default)
sawine@5: 		hrefNormalized: ( a.getAttribute( "href" ) === "/a" ),
sawine@5: 
sawine@5: 		// Make sure that element opacity exists
sawine@5: 		// (IE uses filter instead)
sawine@5: 		// Use a regex to work around a WebKit issue. See #5145
sawine@5: 		opacity: /^0.55$/.test( a.style.opacity ),
sawine@5: 
sawine@5: 		// Verify style float existence
sawine@5: 		// (IE uses styleFloat instead of cssFloat)
sawine@5: 		cssFloat: !!a.style.cssFloat,
sawine@5: 
sawine@5: 		// Make sure that if no value is specified for a checkbox
sawine@5: 		// that it defaults to "on".
sawine@5: 		// (WebKit defaults to "" instead)
sawine@5: 		checkOn: ( input.value === "on" ),
sawine@5: 
sawine@5: 		// Make sure that a selected-by-default option has a working selected property.
sawine@5: 		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
sawine@5: 		optSelected: opt.selected,
sawine@5: 
sawine@5: 		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
sawine@5: 		getSetAttribute: div.className !== "t",
sawine@5: 
sawine@5: 		// Will be defined later
sawine@5: 		submitBubbles: true,
sawine@5: 		changeBubbles: true,
sawine@5: 		focusinBubbles: false,
sawine@5: 		deleteExpando: true,
sawine@5: 		noCloneEvent: true,
sawine@5: 		inlineBlockNeedsLayout: false,
sawine@5: 		shrinkWrapBlocks: false,
sawine@5: 		reliableMarginRight: true
sawine@5: 	};
sawine@5: 
sawine@5: 	// Make sure checked status is properly cloned
sawine@5: 	input.checked = true;
sawine@5: 	support.noCloneChecked = input.cloneNode( true ).checked;
sawine@5: 
sawine@5: 	// Make sure that the options inside disabled selects aren't marked as disabled
sawine@5: 	// (WebKit marks them as disabled)
sawine@5: 	select.disabled = true;
sawine@5: 	support.optDisabled = !opt.disabled;
sawine@5: 
sawine@5: 	// Test to see if it's possible to delete an expando from an element
sawine@5: 	// Fails in Internet Explorer
sawine@5: 	try {
sawine@5: 		delete div.test;
sawine@5: 	} catch( e ) {
sawine@5: 		support.deleteExpando = false;
sawine@5: 	}
sawine@5: 
sawine@5: 	if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
sawine@5: 		div.attachEvent( "onclick", function() {
sawine@5: 			// Cloning a node shouldn't copy over any
sawine@5: 			// bound event handlers (IE does this)
sawine@5: 			support.noCloneEvent = false;
sawine@5: 		});
sawine@5: 		div.cloneNode( true ).fireEvent( "onclick" );
sawine@5: 	}
sawine@5: 
sawine@5: 	// Check if a radio maintains it's value
sawine@5: 	// after being appended to the DOM
sawine@5: 	input = document.createElement("input");
sawine@5: 	input.value = "t";
sawine@5: 	input.setAttribute("type", "radio");
sawine@5: 	support.radioValue = input.value === "t";
sawine@5: 
sawine@5: 	input.setAttribute("checked", "checked");
sawine@5: 	div.appendChild( input );
sawine@5: 	fragment = document.createDocumentFragment();
sawine@5: 	fragment.appendChild( div.firstChild );
sawine@5: 
sawine@5: 	// WebKit doesn't clone checked state correctly in fragments
sawine@5: 	support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
sawine@5: 
sawine@5: 	div.innerHTML = "";
sawine@5: 
sawine@5: 	// Figure out if the W3C box model works as expected
sawine@5: 	div.style.width = div.style.paddingLeft = "1px";
sawine@5: 
sawine@5: 	body = document.getElementsByTagName( "body" )[ 0 ];
sawine@5: 	// We use our own, invisible, body unless the body is already present
sawine@5: 	// in which case we use a div (#9239)
sawine@5: 	testElement = document.createElement( body ? "div" : "body" );
sawine@5: 	testElementStyle = {
sawine@5: 		visibility: "hidden",
sawine@5: 		width: 0,
sawine@5: 		height: 0,
sawine@5: 		border: 0,
sawine@5: 		margin: 0,
sawine@5: 		background: "none"
sawine@5: 	};
sawine@5: 	if ( body ) {
sawine@5: 		jQuery.extend( testElementStyle, {
sawine@5: 			position: "absolute",
sawine@5: 			left: "-1000px",
sawine@5: 			top: "-1000px"
sawine@5: 		});
sawine@5: 	}
sawine@5: 	for ( i in testElementStyle ) {
sawine@5: 		testElement.style[ i ] = testElementStyle[ i ];
sawine@5: 	}
sawine@5: 	testElement.appendChild( div );
sawine@5: 	testElementParent = body || documentElement;
sawine@5: 	testElementParent.insertBefore( testElement, testElementParent.firstChild );
sawine@5: 
sawine@5: 	// Check if a disconnected checkbox will retain its checked
sawine@5: 	// value of true after appended to the DOM (IE6/7)
sawine@5: 	support.appendChecked = input.checked;
sawine@5: 
sawine@5: 	support.boxModel = div.offsetWidth === 2;
sawine@5: 
sawine@5: 	if ( "zoom" in div.style ) {
sawine@5: 		// Check if natively block-level elements act like inline-block
sawine@5: 		// elements when setting their display to 'inline' and giving
sawine@5: 		// them layout
sawine@5: 		// (IE < 8 does this)
sawine@5: 		div.style.display = "inline";
sawine@5: 		div.style.zoom = 1;
sawine@5: 		support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
sawine@5: 
sawine@5: 		// Check if elements with layout shrink-wrap their children
sawine@5: 		// (IE 6 does this)
sawine@5: 		div.style.display = "";
sawine@5: 		div.innerHTML = "<div style='width:4px;'></div>";
sawine@5: 		support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
sawine@5: 	}
sawine@5: 
sawine@5: 	div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
sawine@5: 	tds = div.getElementsByTagName( "td" );
sawine@5: 
sawine@5: 	// Check if table cells still have offsetWidth/Height when they are set
sawine@5: 	// to display:none and there are still other visible table cells in a
sawine@5: 	// table row; if so, offsetWidth/Height are not reliable for use when
sawine@5: 	// determining if an element has been hidden directly using
sawine@5: 	// display:none (it is still safe to use offsets if a parent element is
sawine@5: 	// hidden; don safety goggles and see bug #4512 for more information).
sawine@5: 	// (only IE 8 fails this test)
sawine@5: 	isSupported = ( tds[ 0 ].offsetHeight === 0 );
sawine@5: 
sawine@5: 	tds[ 0 ].style.display = "";
sawine@5: 	tds[ 1 ].style.display = "none";
sawine@5: 
sawine@5: 	// Check if empty table cells still have offsetWidth/Height
sawine@5: 	// (IE < 8 fail this test)
sawine@5: 	support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
sawine@5: 	div.innerHTML = "";
sawine@5: 
sawine@5: 	// Check if div with explicit width and no margin-right incorrectly
sawine@5: 	// gets computed margin-right based on width of container. For more
sawine@5: 	// info see bug #3333
sawine@5: 	// Fails in WebKit before Feb 2011 nightlies
sawine@5: 	// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
sawine@5: 	if ( document.defaultView && document.defaultView.getComputedStyle ) {
sawine@5: 		marginDiv = document.createElement( "div" );
sawine@5: 		marginDiv.style.width = "0";
sawine@5: 		marginDiv.style.marginRight = "0";
sawine@5: 		div.appendChild( marginDiv );
sawine@5: 		support.reliableMarginRight =
sawine@5: 			( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
sawine@5: 	}
sawine@5: 
sawine@5: 	// Remove the body element we added
sawine@5: 	testElement.innerHTML = "";
sawine@5: 	testElementParent.removeChild( testElement );
sawine@5: 
sawine@5: 	// Technique from Juriy Zaytsev
sawine@5: 	// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
sawine@5: 	// We only care about the case where non-standard event systems
sawine@5: 	// are used, namely in IE. Short-circuiting here helps us to
sawine@5: 	// avoid an eval call (in setAttribute) which can cause CSP
sawine@5: 	// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
sawine@5: 	if ( div.attachEvent ) {
sawine@5: 		for( i in {
sawine@5: 			submit: 1,
sawine@5: 			change: 1,
sawine@5: 			focusin: 1
sawine@5: 		} ) {
sawine@5: 			eventName = "on" + i;
sawine@5: 			isSupported = ( eventName in div );
sawine@5: 			if ( !isSupported ) {
sawine@5: 				div.setAttribute( eventName, "return;" );
sawine@5: 				isSupported = ( typeof div[ eventName ] === "function" );
sawine@5: 			}
sawine@5: 			support[ i + "Bubbles" ] = isSupported;
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	// Null connected elements to avoid leaks in IE
sawine@5: 	testElement = fragment = select = opt = body = marginDiv = div = input = null;
sawine@5: 
sawine@5: 	return support;
sawine@5: })();
sawine@5: 
sawine@5: // Keep track of boxModel
sawine@5: jQuery.boxModel = jQuery.support.boxModel;
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: var rbrace = /^(?:\{.*\}|\[.*\])$/,
sawine@5: 	rmultiDash = /([A-Z])/g;
sawine@5: 
sawine@5: jQuery.extend({
sawine@5: 	cache: {},
sawine@5: 
sawine@5: 	// Please use with caution
sawine@5: 	uuid: 0,
sawine@5: 
sawine@5: 	// Unique for each copy of jQuery on the page
sawine@5: 	// Non-digits removed to match rinlinejQuery
sawine@5: 	expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
sawine@5: 
sawine@5: 	// The following elements throw uncatchable exceptions if you
sawine@5: 	// attempt to add expando properties to them.
sawine@5: 	noData: {
sawine@5: 		"embed": true,
sawine@5: 		// Ban all objects except for Flash (which handle expandos)
sawine@5: 		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
sawine@5: 		"applet": true
sawine@5: 	},
sawine@5: 
sawine@5: 	hasData: function( elem ) {
sawine@5: 		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
sawine@5: 
sawine@5: 		return !!elem && !isEmptyDataObject( elem );
sawine@5: 	},
sawine@5: 
sawine@5: 	data: function( elem, name, data, pvt /* Internal Use Only */ ) {
sawine@5: 		if ( !jQuery.acceptData( elem ) ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		var thisCache, ret,
sawine@5: 			internalKey = jQuery.expando,
sawine@5: 			getByName = typeof name === "string",
sawine@5: 
sawine@5: 			// We have to handle DOM nodes and JS objects differently because IE6-7
sawine@5: 			// can't GC object references properly across the DOM-JS boundary
sawine@5: 			isNode = elem.nodeType,
sawine@5: 
sawine@5: 			// Only DOM nodes need the global jQuery cache; JS object data is
sawine@5: 			// attached directly to the object so GC can occur automatically
sawine@5: 			cache = isNode ? jQuery.cache : elem,
sawine@5: 
sawine@5: 			// Only defining an ID for JS objects if its cache already exists allows
sawine@5: 			// the code to shortcut on the same path as a DOM node with no cache
sawine@5: 			id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
sawine@5: 
sawine@5: 		// Avoid doing any more work than we need to when trying to get data on an
sawine@5: 		// object that has no data at all
sawine@5: 		if ( (!id || (pvt && id && (cache[ id ] && !cache[ id ][ internalKey ]))) && getByName && data === undefined ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( !id ) {
sawine@5: 			// Only DOM nodes need a new unique ID for each element since their data
sawine@5: 			// ends up in the global cache
sawine@5: 			if ( isNode ) {
sawine@5: 				elem[ jQuery.expando ] = id = ++jQuery.uuid;
sawine@5: 			} else {
sawine@5: 				id = jQuery.expando;
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( !cache[ id ] ) {
sawine@5: 			cache[ id ] = {};
sawine@5: 
sawine@5: 			// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
sawine@5: 			// metadata on plain JS objects when the object is serialized using
sawine@5: 			// JSON.stringify
sawine@5: 			if ( !isNode ) {
sawine@5: 				cache[ id ].toJSON = jQuery.noop;
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		// An object can be passed to jQuery.data instead of a key/value pair; this gets
sawine@5: 		// shallow copied over onto the existing cache
sawine@5: 		if ( typeof name === "object" || typeof name === "function" ) {
sawine@5: 			if ( pvt ) {
sawine@5: 				cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
sawine@5: 			} else {
sawine@5: 				cache[ id ] = jQuery.extend(cache[ id ], name);
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		thisCache = cache[ id ];
sawine@5: 
sawine@5: 		// Internal jQuery data is stored in a separate object inside the object's data
sawine@5: 		// cache in order to avoid key collisions between internal data and user-defined
sawine@5: 		// data
sawine@5: 		if ( pvt ) {
sawine@5: 			if ( !thisCache[ internalKey ] ) {
sawine@5: 				thisCache[ internalKey ] = {};
sawine@5: 			}
sawine@5: 
sawine@5: 			thisCache = thisCache[ internalKey ];
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( data !== undefined ) {
sawine@5: 			thisCache[ jQuery.camelCase( name ) ] = data;
sawine@5: 		}
sawine@5: 
sawine@5: 		// TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
sawine@5: 		// not attempt to inspect the internal events object using jQuery.data, as this
sawine@5: 		// internal data object is undocumented and subject to change.
sawine@5: 		if ( name === "events" && !thisCache[name] ) {
sawine@5: 			return thisCache[ internalKey ] && thisCache[ internalKey ].events;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Check for both converted-to-camel and non-converted data property names
sawine@5: 		// If a data property was specified
sawine@5: 		if ( getByName ) {
sawine@5: 
sawine@5: 			// First Try to find as-is property data
sawine@5: 			ret = thisCache[ name ];
sawine@5: 
sawine@5: 			// Test for null|undefined property data
sawine@5: 			if ( ret == null ) {
sawine@5: 
sawine@5: 				// Try to find the camelCased property
sawine@5: 				ret = thisCache[ jQuery.camelCase( name ) ];
sawine@5: 			}
sawine@5: 		} else {
sawine@5: 			ret = thisCache;
sawine@5: 		}
sawine@5: 
sawine@5: 		return ret;
sawine@5: 	},
sawine@5: 
sawine@5: 	removeData: function( elem, name, pvt /* Internal Use Only */ ) {
sawine@5: 		if ( !jQuery.acceptData( elem ) ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		var thisCache,
sawine@5: 
sawine@5: 			// Reference to internal data cache key
sawine@5: 			internalKey = jQuery.expando,
sawine@5: 
sawine@5: 			isNode = elem.nodeType,
sawine@5: 
sawine@5: 			// See jQuery.data for more information
sawine@5: 			cache = isNode ? jQuery.cache : elem,
sawine@5: 
sawine@5: 			// See jQuery.data for more information
sawine@5: 			id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
sawine@5: 
sawine@5: 		// If there is already no cache entry for this object, there is no
sawine@5: 		// purpose in continuing
sawine@5: 		if ( !cache[ id ] ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( name ) {
sawine@5: 
sawine@5: 			thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
sawine@5: 
sawine@5: 			if ( thisCache ) {
sawine@5: 
sawine@5: 				// Support interoperable removal of hyphenated or camelcased keys
sawine@5: 				if ( !thisCache[ name ] ) {
sawine@5: 					name = jQuery.camelCase( name );
sawine@5: 				}
sawine@5: 
sawine@5: 				delete thisCache[ name ];
sawine@5: 
sawine@5: 				// If there is no data left in the cache, we want to continue
sawine@5: 				// and let the cache object itself get destroyed
sawine@5: 				if ( !isEmptyDataObject(thisCache) ) {
sawine@5: 					return;
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		// See jQuery.data for more information
sawine@5: 		if ( pvt ) {
sawine@5: 			delete cache[ id ][ internalKey ];
sawine@5: 
sawine@5: 			// Don't destroy the parent cache unless the internal data object
sawine@5: 			// had been the only thing left in it
sawine@5: 			if ( !isEmptyDataObject(cache[ id ]) ) {
sawine@5: 				return;
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		var internalCache = cache[ id ][ internalKey ];
sawine@5: 
sawine@5: 		// Browsers that fail expando deletion also refuse to delete expandos on
sawine@5: 		// the window, but it will allow it on all other JS objects; other browsers
sawine@5: 		// don't care
sawine@5: 		// Ensure that `cache` is not a window object #10080
sawine@5: 		if ( jQuery.support.deleteExpando || !cache.setInterval ) {
sawine@5: 			delete cache[ id ];
sawine@5: 		} else {
sawine@5: 			cache[ id ] = null;
sawine@5: 		}
sawine@5: 
sawine@5: 		// We destroyed the entire user cache at once because it's faster than
sawine@5: 		// iterating through each key, but we need to continue to persist internal
sawine@5: 		// data if it existed
sawine@5: 		if ( internalCache ) {
sawine@5: 			cache[ id ] = {};
sawine@5: 			// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
sawine@5: 			// metadata on plain JS objects when the object is serialized using
sawine@5: 			// JSON.stringify
sawine@5: 			if ( !isNode ) {
sawine@5: 				cache[ id ].toJSON = jQuery.noop;
sawine@5: 			}
sawine@5: 
sawine@5: 			cache[ id ][ internalKey ] = internalCache;
sawine@5: 
sawine@5: 		// Otherwise, we need to eliminate the expando on the node to avoid
sawine@5: 		// false lookups in the cache for entries that no longer exist
sawine@5: 		} else if ( isNode ) {
sawine@5: 			// IE does not allow us to delete expando properties from nodes,
sawine@5: 			// nor does it have a removeAttribute function on Document nodes;
sawine@5: 			// we must handle all of these cases
sawine@5: 			if ( jQuery.support.deleteExpando ) {
sawine@5: 				delete elem[ jQuery.expando ];
sawine@5: 			} else if ( elem.removeAttribute ) {
sawine@5: 				elem.removeAttribute( jQuery.expando );
sawine@5: 			} else {
sawine@5: 				elem[ jQuery.expando ] = null;
sawine@5: 			}
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	// For internal use only.
sawine@5: 	_data: function( elem, name, data ) {
sawine@5: 		return jQuery.data( elem, name, data, true );
sawine@5: 	},
sawine@5: 
sawine@5: 	// A method for determining if a DOM node can handle the data expando
sawine@5: 	acceptData: function( elem ) {
sawine@5: 		if ( elem.nodeName ) {
sawine@5: 			var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
sawine@5: 
sawine@5: 			if ( match ) {
sawine@5: 				return !(match === true || elem.getAttribute("classid") !== match);
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return true;
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: jQuery.fn.extend({
sawine@5: 	data: function( key, value ) {
sawine@5: 		var data = null;
sawine@5: 
sawine@5: 		if ( typeof key === "undefined" ) {
sawine@5: 			if ( this.length ) {
sawine@5: 				data = jQuery.data( this[0] );
sawine@5: 
sawine@5: 				if ( this[0].nodeType === 1 ) {
sawine@5: 			    var attr = this[0].attributes, name;
sawine@5: 					for ( var i = 0, l = attr.length; i < l; i++ ) {
sawine@5: 						name = attr[i].name;
sawine@5: 
sawine@5: 						if ( name.indexOf( "data-" ) === 0 ) {
sawine@5: 							name = jQuery.camelCase( name.substring(5) );
sawine@5: 
sawine@5: 							dataAttr( this[0], name, data[ name ] );
sawine@5: 						}
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			return data;
sawine@5: 
sawine@5: 		} else if ( typeof key === "object" ) {
sawine@5: 			return this.each(function() {
sawine@5: 				jQuery.data( this, key );
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		var parts = key.split(".");
sawine@5: 		parts[1] = parts[1] ? "." + parts[1] : "";
sawine@5: 
sawine@5: 		if ( value === undefined ) {
sawine@5: 			data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
sawine@5: 
sawine@5: 			// Try to fetch any internally stored data first
sawine@5: 			if ( data === undefined && this.length ) {
sawine@5: 				data = jQuery.data( this[0], key );
sawine@5: 				data = dataAttr( this[0], key, data );
sawine@5: 			}
sawine@5: 
sawine@5: 			return data === undefined && parts[1] ?
sawine@5: 				this.data( parts[0] ) :
sawine@5: 				data;
sawine@5: 
sawine@5: 		} else {
sawine@5: 			return this.each(function() {
sawine@5: 				var $this = jQuery( this ),
sawine@5: 					args = [ parts[0], value ];
sawine@5: 
sawine@5: 				$this.triggerHandler( "setData" + parts[1] + "!", args );
sawine@5: 				jQuery.data( this, key, value );
sawine@5: 				$this.triggerHandler( "changeData" + parts[1] + "!", args );
sawine@5: 			});
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	removeData: function( key ) {
sawine@5: 		return this.each(function() {
sawine@5: 			jQuery.removeData( this, key );
sawine@5: 		});
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: function dataAttr( elem, key, data ) {
sawine@5: 	// If nothing was found internally, try to fetch any
sawine@5: 	// data from the HTML5 data-* attribute
sawine@5: 	if ( data === undefined && elem.nodeType === 1 ) {
sawine@5: 
sawine@5: 		var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
sawine@5: 
sawine@5: 		data = elem.getAttribute( name );
sawine@5: 
sawine@5: 		if ( typeof data === "string" ) {
sawine@5: 			try {
sawine@5: 				data = data === "true" ? true :
sawine@5: 				data === "false" ? false :
sawine@5: 				data === "null" ? null :
sawine@5: 				!jQuery.isNaN( data ) ? parseFloat( data ) :
sawine@5: 					rbrace.test( data ) ? jQuery.parseJSON( data ) :
sawine@5: 					data;
sawine@5: 			} catch( e ) {}
sawine@5: 
sawine@5: 			// Make sure we set the data so it isn't changed later
sawine@5: 			jQuery.data( elem, key, data );
sawine@5: 
sawine@5: 		} else {
sawine@5: 			data = undefined;
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	return data;
sawine@5: }
sawine@5: 
sawine@5: // TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
sawine@5: // property to be considered empty objects; this property always exists in
sawine@5: // order to make sure JSON.stringify does not expose internal metadata
sawine@5: function isEmptyDataObject( obj ) {
sawine@5: 	for ( var name in obj ) {
sawine@5: 		if ( name !== "toJSON" ) {
sawine@5: 			return false;
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	return true;
sawine@5: }
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: function handleQueueMarkDefer( elem, type, src ) {
sawine@5: 	var deferDataKey = type + "defer",
sawine@5: 		queueDataKey = type + "queue",
sawine@5: 		markDataKey = type + "mark",
sawine@5: 		defer = jQuery.data( elem, deferDataKey, undefined, true );
sawine@5: 	if ( defer &&
sawine@5: 		( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
sawine@5: 		( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
sawine@5: 		// Give room for hard-coded callbacks to fire first
sawine@5: 		// and eventually mark/queue something else on the element
sawine@5: 		setTimeout( function() {
sawine@5: 			if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
sawine@5: 				!jQuery.data( elem, markDataKey, undefined, true ) ) {
sawine@5: 				jQuery.removeData( elem, deferDataKey, true );
sawine@5: 				defer.resolve();
sawine@5: 			}
sawine@5: 		}, 0 );
sawine@5: 	}
sawine@5: }
sawine@5: 
sawine@5: jQuery.extend({
sawine@5: 
sawine@5: 	_mark: function( elem, type ) {
sawine@5: 		if ( elem ) {
sawine@5: 			type = (type || "fx") + "mark";
sawine@5: 			jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true );
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	_unmark: function( force, elem, type ) {
sawine@5: 		if ( force !== true ) {
sawine@5: 			type = elem;
sawine@5: 			elem = force;
sawine@5: 			force = false;
sawine@5: 		}
sawine@5: 		if ( elem ) {
sawine@5: 			type = type || "fx";
sawine@5: 			var key = type + "mark",
sawine@5: 				count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) || 1 ) - 1 );
sawine@5: 			if ( count ) {
sawine@5: 				jQuery.data( elem, key, count, true );
sawine@5: 			} else {
sawine@5: 				jQuery.removeData( elem, key, true );
sawine@5: 				handleQueueMarkDefer( elem, type, "mark" );
sawine@5: 			}
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	queue: function( elem, type, data ) {
sawine@5: 		if ( elem ) {
sawine@5: 			type = (type || "fx") + "queue";
sawine@5: 			var q = jQuery.data( elem, type, undefined, true );
sawine@5: 			// Speed up dequeue by getting out quickly if this is just a lookup
sawine@5: 			if ( data ) {
sawine@5: 				if ( !q || jQuery.isArray(data) ) {
sawine@5: 					q = jQuery.data( elem, type, jQuery.makeArray(data), true );
sawine@5: 				} else {
sawine@5: 					q.push( data );
sawine@5: 				}
sawine@5: 			}
sawine@5: 			return q || [];
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	dequeue: function( elem, type ) {
sawine@5: 		type = type || "fx";
sawine@5: 
sawine@5: 		var queue = jQuery.queue( elem, type ),
sawine@5: 			fn = queue.shift(),
sawine@5: 			defer;
sawine@5: 
sawine@5: 		// If the fx queue is dequeued, always remove the progress sentinel
sawine@5: 		if ( fn === "inprogress" ) {
sawine@5: 			fn = queue.shift();
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( fn ) {
sawine@5: 			// Add a progress sentinel to prevent the fx queue from being
sawine@5: 			// automatically dequeued
sawine@5: 			if ( type === "fx" ) {
sawine@5: 				queue.unshift("inprogress");
sawine@5: 			}
sawine@5: 
sawine@5: 			fn.call(elem, function() {
sawine@5: 				jQuery.dequeue(elem, type);
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( !queue.length ) {
sawine@5: 			jQuery.removeData( elem, type + "queue", true );
sawine@5: 			handleQueueMarkDefer( elem, type, "queue" );
sawine@5: 		}
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: jQuery.fn.extend({
sawine@5: 	queue: function( type, data ) {
sawine@5: 		if ( typeof type !== "string" ) {
sawine@5: 			data = type;
sawine@5: 			type = "fx";
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( data === undefined ) {
sawine@5: 			return jQuery.queue( this[0], type );
sawine@5: 		}
sawine@5: 		return this.each(function() {
sawine@5: 			var queue = jQuery.queue( this, type, data );
sawine@5: 
sawine@5: 			if ( type === "fx" && queue[0] !== "inprogress" ) {
sawine@5: 				jQuery.dequeue( this, type );
sawine@5: 			}
sawine@5: 		});
sawine@5: 	},
sawine@5: 	dequeue: function( type ) {
sawine@5: 		return this.each(function() {
sawine@5: 			jQuery.dequeue( this, type );
sawine@5: 		});
sawine@5: 	},
sawine@5: 	// Based off of the plugin by Clint Helfers, with permission.
sawine@5: 	// http://blindsignals.com/index.php/2009/07/jquery-delay/
sawine@5: 	delay: function( time, type ) {
sawine@5: 		time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
sawine@5: 		type = type || "fx";
sawine@5: 
sawine@5: 		return this.queue( type, function() {
sawine@5: 			var elem = this;
sawine@5: 			setTimeout(function() {
sawine@5: 				jQuery.dequeue( elem, type );
sawine@5: 			}, time );
sawine@5: 		});
sawine@5: 	},
sawine@5: 	clearQueue: function( type ) {
sawine@5: 		return this.queue( type || "fx", [] );
sawine@5: 	},
sawine@5: 	// Get a promise resolved when queues of a certain type
sawine@5: 	// are emptied (fx is the type by default)
sawine@5: 	promise: function( type, object ) {
sawine@5: 		if ( typeof type !== "string" ) {
sawine@5: 			object = type;
sawine@5: 			type = undefined;
sawine@5: 		}
sawine@5: 		type = type || "fx";
sawine@5: 		var defer = jQuery.Deferred(),
sawine@5: 			elements = this,
sawine@5: 			i = elements.length,
sawine@5: 			count = 1,
sawine@5: 			deferDataKey = type + "defer",
sawine@5: 			queueDataKey = type + "queue",
sawine@5: 			markDataKey = type + "mark",
sawine@5: 			tmp;
sawine@5: 		function resolve() {
sawine@5: 			if ( !( --count ) ) {
sawine@5: 				defer.resolveWith( elements, [ elements ] );
sawine@5: 			}
sawine@5: 		}
sawine@5: 		while( i-- ) {
sawine@5: 			if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
sawine@5: 					( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
sawine@5: 						jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
sawine@5: 					jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) {
sawine@5: 				count++;
sawine@5: 				tmp.done( resolve );
sawine@5: 			}
sawine@5: 		}
sawine@5: 		resolve();
sawine@5: 		return defer.promise();
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: var rclass = /[\n\t\r]/g,
sawine@5: 	rspace = /\s+/,
sawine@5: 	rreturn = /\r/g,
sawine@5: 	rtype = /^(?:button|input)$/i,
sawine@5: 	rfocusable = /^(?:button|input|object|select|textarea)$/i,
sawine@5: 	rclickable = /^a(?:rea)?$/i,
sawine@5: 	rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
sawine@5: 	nodeHook, boolHook;
sawine@5: 
sawine@5: jQuery.fn.extend({
sawine@5: 	attr: function( name, value ) {
sawine@5: 		return jQuery.access( this, name, value, true, jQuery.attr );
sawine@5: 	},
sawine@5: 
sawine@5: 	removeAttr: function( name ) {
sawine@5: 		return this.each(function() {
sawine@5: 			jQuery.removeAttr( this, name );
sawine@5: 		});
sawine@5: 	},
sawine@5: 	
sawine@5: 	prop: function( name, value ) {
sawine@5: 		return jQuery.access( this, name, value, true, jQuery.prop );
sawine@5: 	},
sawine@5: 	
sawine@5: 	removeProp: function( name ) {
sawine@5: 		name = jQuery.propFix[ name ] || name;
sawine@5: 		return this.each(function() {
sawine@5: 			// try/catch handles cases where IE balks (such as removing a property on window)
sawine@5: 			try {
sawine@5: 				this[ name ] = undefined;
sawine@5: 				delete this[ name ];
sawine@5: 			} catch( e ) {}
sawine@5: 		});
sawine@5: 	},
sawine@5: 
sawine@5: 	addClass: function( value ) {
sawine@5: 		var classNames, i, l, elem,
sawine@5: 			setClass, c, cl;
sawine@5: 
sawine@5: 		if ( jQuery.isFunction( value ) ) {
sawine@5: 			return this.each(function( j ) {
sawine@5: 				jQuery( this ).addClass( value.call(this, j, this.className) );
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( value && typeof value === "string" ) {
sawine@5: 			classNames = value.split( rspace );
sawine@5: 
sawine@5: 			for ( i = 0, l = this.length; i < l; i++ ) {
sawine@5: 				elem = this[ i ];
sawine@5: 
sawine@5: 				if ( elem.nodeType === 1 ) {
sawine@5: 					if ( !elem.className && classNames.length === 1 ) {
sawine@5: 						elem.className = value;
sawine@5: 
sawine@5: 					} else {
sawine@5: 						setClass = " " + elem.className + " ";
sawine@5: 
sawine@5: 						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
sawine@5: 							if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
sawine@5: 								setClass += classNames[ c ] + " ";
sawine@5: 							}
sawine@5: 						}
sawine@5: 						elem.className = jQuery.trim( setClass );
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return this;
sawine@5: 	},
sawine@5: 
sawine@5: 	removeClass: function( value ) {
sawine@5: 		var classNames, i, l, elem, className, c, cl;
sawine@5: 
sawine@5: 		if ( jQuery.isFunction( value ) ) {
sawine@5: 			return this.each(function( j ) {
sawine@5: 				jQuery( this ).removeClass( value.call(this, j, this.className) );
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( (value && typeof value === "string") || value === undefined ) {
sawine@5: 			classNames = (value || "").split( rspace );
sawine@5: 
sawine@5: 			for ( i = 0, l = this.length; i < l; i++ ) {
sawine@5: 				elem = this[ i ];
sawine@5: 
sawine@5: 				if ( elem.nodeType === 1 && elem.className ) {
sawine@5: 					if ( value ) {
sawine@5: 						className = (" " + elem.className + " ").replace( rclass, " " );
sawine@5: 						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
sawine@5: 							className = className.replace(" " + classNames[ c ] + " ", " ");
sawine@5: 						}
sawine@5: 						elem.className = jQuery.trim( className );
sawine@5: 
sawine@5: 					} else {
sawine@5: 						elem.className = "";
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return this;
sawine@5: 	},
sawine@5: 
sawine@5: 	toggleClass: function( value, stateVal ) {
sawine@5: 		var type = typeof value,
sawine@5: 			isBool = typeof stateVal === "boolean";
sawine@5: 
sawine@5: 		if ( jQuery.isFunction( value ) ) {
sawine@5: 			return this.each(function( i ) {
sawine@5: 				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		return this.each(function() {
sawine@5: 			if ( type === "string" ) {
sawine@5: 				// toggle individual class names
sawine@5: 				var className,
sawine@5: 					i = 0,
sawine@5: 					self = jQuery( this ),
sawine@5: 					state = stateVal,
sawine@5: 					classNames = value.split( rspace );
sawine@5: 
sawine@5: 				while ( (className = classNames[ i++ ]) ) {
sawine@5: 					// check each className given, space seperated list
sawine@5: 					state = isBool ? state : !self.hasClass( className );
sawine@5: 					self[ state ? "addClass" : "removeClass" ]( className );
sawine@5: 				}
sawine@5: 
sawine@5: 			} else if ( type === "undefined" || type === "boolean" ) {
sawine@5: 				if ( this.className ) {
sawine@5: 					// store className if set
sawine@5: 					jQuery._data( this, "__className__", this.className );
sawine@5: 				}
sawine@5: 
sawine@5: 				// toggle whole className
sawine@5: 				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
sawine@5: 			}
sawine@5: 		});
sawine@5: 	},
sawine@5: 
sawine@5: 	hasClass: function( selector ) {
sawine@5: 		var className = " " + selector + " ";
sawine@5: 		for ( var i = 0, l = this.length; i < l; i++ ) {
sawine@5: 			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
sawine@5: 				return true;
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return false;
sawine@5: 	},
sawine@5: 
sawine@5: 	val: function( value ) {
sawine@5: 		var hooks, ret,
sawine@5: 			elem = this[0];
sawine@5: 		
sawine@5: 		if ( !arguments.length ) {
sawine@5: 			if ( elem ) {
sawine@5: 				hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ];
sawine@5: 
sawine@5: 				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
sawine@5: 					return ret;
sawine@5: 				}
sawine@5: 
sawine@5: 				ret = elem.value;
sawine@5: 
sawine@5: 				return typeof ret === "string" ? 
sawine@5: 					// handle most common string cases
sawine@5: 					ret.replace(rreturn, "") : 
sawine@5: 					// handle cases where value is null/undef or number
sawine@5: 					ret == null ? "" : ret;
sawine@5: 			}
sawine@5: 
sawine@5: 			return undefined;
sawine@5: 		}
sawine@5: 
sawine@5: 		var isFunction = jQuery.isFunction( value );
sawine@5: 
sawine@5: 		return this.each(function( i ) {
sawine@5: 			var self = jQuery(this), val;
sawine@5: 
sawine@5: 			if ( this.nodeType !== 1 ) {
sawine@5: 				return;
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( isFunction ) {
sawine@5: 				val = value.call( this, i, self.val() );
sawine@5: 			} else {
sawine@5: 				val = value;
sawine@5: 			}
sawine@5: 
sawine@5: 			// Treat null/undefined as ""; convert numbers to string
sawine@5: 			if ( val == null ) {
sawine@5: 				val = "";
sawine@5: 			} else if ( typeof val === "number" ) {
sawine@5: 				val += "";
sawine@5: 			} else if ( jQuery.isArray( val ) ) {
sawine@5: 				val = jQuery.map(val, function ( value ) {
sawine@5: 					return value == null ? "" : value + "";
sawine@5: 				});
sawine@5: 			}
sawine@5: 
sawine@5: 			hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ];
sawine@5: 
sawine@5: 			// If set returns undefined, fall back to normal setting
sawine@5: 			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
sawine@5: 				this.value = val;
sawine@5: 			}
sawine@5: 		});
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: jQuery.extend({
sawine@5: 	valHooks: {
sawine@5: 		option: {
sawine@5: 			get: function( elem ) {
sawine@5: 				// attributes.value is undefined in Blackberry 4.7 but
sawine@5: 				// uses .value. See #6932
sawine@5: 				var val = elem.attributes.value;
sawine@5: 				return !val || val.specified ? elem.value : elem.text;
sawine@5: 			}
sawine@5: 		},
sawine@5: 		select: {
sawine@5: 			get: function( elem ) {
sawine@5: 				var value,
sawine@5: 					index = elem.selectedIndex,
sawine@5: 					values = [],
sawine@5: 					options = elem.options,
sawine@5: 					one = elem.type === "select-one";
sawine@5: 
sawine@5: 				// Nothing was selected
sawine@5: 				if ( index < 0 ) {
sawine@5: 					return null;
sawine@5: 				}
sawine@5: 
sawine@5: 				// Loop through all the selected options
sawine@5: 				for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
sawine@5: 					var option = options[ i ];
sawine@5: 
sawine@5: 					// Don't return options that are disabled or in a disabled optgroup
sawine@5: 					if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
sawine@5: 							(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
sawine@5: 
sawine@5: 						// Get the specific value for the option
sawine@5: 						value = jQuery( option ).val();
sawine@5: 
sawine@5: 						// We don't need an array for one selects
sawine@5: 						if ( one ) {
sawine@5: 							return value;
sawine@5: 						}
sawine@5: 
sawine@5: 						// Multi-Selects return an array
sawine@5: 						values.push( value );
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
sawine@5: 				if ( one && !values.length && options.length ) {
sawine@5: 					return jQuery( options[ index ] ).val();
sawine@5: 				}
sawine@5: 
sawine@5: 				return values;
sawine@5: 			},
sawine@5: 
sawine@5: 			set: function( elem, value ) {
sawine@5: 				var values = jQuery.makeArray( value );
sawine@5: 
sawine@5: 				jQuery(elem).find("option").each(function() {
sawine@5: 					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
sawine@5: 				});
sawine@5: 
sawine@5: 				if ( !values.length ) {
sawine@5: 					elem.selectedIndex = -1;
sawine@5: 				}
sawine@5: 				return values;
sawine@5: 			}
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	attrFn: {
sawine@5: 		val: true,
sawine@5: 		css: true,
sawine@5: 		html: true,
sawine@5: 		text: true,
sawine@5: 		data: true,
sawine@5: 		width: true,
sawine@5: 		height: true,
sawine@5: 		offset: true
sawine@5: 	},
sawine@5: 	
sawine@5: 	attrFix: {
sawine@5: 		// Always normalize to ensure hook usage
sawine@5: 		tabindex: "tabIndex"
sawine@5: 	},
sawine@5: 	
sawine@5: 	attr: function( elem, name, value, pass ) {
sawine@5: 		var nType = elem.nodeType;
sawine@5: 		
sawine@5: 		// don't get/set attributes on text, comment and attribute nodes
sawine@5: 		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
sawine@5: 			return undefined;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( pass && name in jQuery.attrFn ) {
sawine@5: 			return jQuery( elem )[ name ]( value );
sawine@5: 		}
sawine@5: 
sawine@5: 		// Fallback to prop when attributes are not supported
sawine@5: 		if ( !("getAttribute" in elem) ) {
sawine@5: 			return jQuery.prop( elem, name, value );
sawine@5: 		}
sawine@5: 
sawine@5: 		var ret, hooks,
sawine@5: 			notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
sawine@5: 
sawine@5: 		// Normalize the name if needed
sawine@5: 		if ( notxml ) {
sawine@5: 			name = jQuery.attrFix[ name ] || name;
sawine@5: 
sawine@5: 			hooks = jQuery.attrHooks[ name ];
sawine@5: 
sawine@5: 			if ( !hooks ) {
sawine@5: 				// Use boolHook for boolean attributes
sawine@5: 				if ( rboolean.test( name ) ) {
sawine@5: 					hooks = boolHook;
sawine@5: 
sawine@5: 				// Use nodeHook if available( IE6/7 )
sawine@5: 				} else if ( nodeHook ) {
sawine@5: 					hooks = nodeHook;
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( value !== undefined ) {
sawine@5: 
sawine@5: 			if ( value === null ) {
sawine@5: 				jQuery.removeAttr( elem, name );
sawine@5: 				return undefined;
sawine@5: 
sawine@5: 			} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
sawine@5: 				return ret;
sawine@5: 
sawine@5: 			} else {
sawine@5: 				elem.setAttribute( name, "" + value );
sawine@5: 				return value;
sawine@5: 			}
sawine@5: 
sawine@5: 		} else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
sawine@5: 			return ret;
sawine@5: 
sawine@5: 		} else {
sawine@5: 
sawine@5: 			ret = elem.getAttribute( name );
sawine@5: 
sawine@5: 			// Non-existent attributes return null, we normalize to undefined
sawine@5: 			return ret === null ?
sawine@5: 				undefined :
sawine@5: 				ret;
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	removeAttr: function( elem, name ) {
sawine@5: 		var propName;
sawine@5: 		if ( elem.nodeType === 1 ) {
sawine@5: 			name = jQuery.attrFix[ name ] || name;
sawine@5: 
sawine@5: 			jQuery.attr( elem, name, "" );
sawine@5: 			elem.removeAttribute( name );
sawine@5: 
sawine@5: 			// Set corresponding property to false for boolean attributes
sawine@5: 			if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] || name) in elem ) {
sawine@5: 				elem[ propName ] = false;
sawine@5: 			}
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	attrHooks: {
sawine@5: 		type: {
sawine@5: 			set: function( elem, value ) {
sawine@5: 				// We can't allow the type property to be changed (since it causes problems in IE)
sawine@5: 				if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
sawine@5: 					jQuery.error( "type property can't be changed" );
sawine@5: 				} else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
sawine@5: 					// Setting the type on a radio button after the value resets the value in IE6-9
sawine@5: 					// Reset value to it's default in case type is set after value
sawine@5: 					// This is for element creation
sawine@5: 					var val = elem.value;
sawine@5: 					elem.setAttribute( "type", value );
sawine@5: 					if ( val ) {
sawine@5: 						elem.value = val;
sawine@5: 					}
sawine@5: 					return value;
sawine@5: 				}
sawine@5: 			}
sawine@5: 		},
sawine@5: 		// Use the value property for back compat
sawine@5: 		// Use the nodeHook for button elements in IE6/7 (#1954)
sawine@5: 		value: {
sawine@5: 			get: function( elem, name ) {
sawine@5: 				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
sawine@5: 					return nodeHook.get( elem, name );
sawine@5: 				}
sawine@5: 				return name in elem ?
sawine@5: 					elem.value :
sawine@5: 					null;
sawine@5: 			},
sawine@5: 			set: function( elem, value, name ) {
sawine@5: 				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
sawine@5: 					return nodeHook.set( elem, value, name );
sawine@5: 				}
sawine@5: 				// Does not return so that setAttribute is also used
sawine@5: 				elem.value = value;
sawine@5: 			}
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	propFix: {
sawine@5: 		tabindex: "tabIndex",
sawine@5: 		readonly: "readOnly",
sawine@5: 		"for": "htmlFor",
sawine@5: 		"class": "className",
sawine@5: 		maxlength: "maxLength",
sawine@5: 		cellspacing: "cellSpacing",
sawine@5: 		cellpadding: "cellPadding",
sawine@5: 		rowspan: "rowSpan",
sawine@5: 		colspan: "colSpan",
sawine@5: 		usemap: "useMap",
sawine@5: 		frameborder: "frameBorder",
sawine@5: 		contenteditable: "contentEditable"
sawine@5: 	},
sawine@5: 	
sawine@5: 	prop: function( elem, name, value ) {
sawine@5: 		var nType = elem.nodeType;
sawine@5: 
sawine@5: 		// don't get/set properties on text, comment and attribute nodes
sawine@5: 		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
sawine@5: 			return undefined;
sawine@5: 		}
sawine@5: 
sawine@5: 		var ret, hooks,
sawine@5: 			notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
sawine@5: 
sawine@5: 		if ( notxml ) {
sawine@5: 			// Fix name and attach hooks
sawine@5: 			name = jQuery.propFix[ name ] || name;
sawine@5: 			hooks = jQuery.propHooks[ name ];
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( value !== undefined ) {
sawine@5: 			if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
sawine@5: 				return ret;
sawine@5: 
sawine@5: 			} else {
sawine@5: 				return (elem[ name ] = value);
sawine@5: 			}
sawine@5: 
sawine@5: 		} else {
sawine@5: 			if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
sawine@5: 				return ret;
sawine@5: 
sawine@5: 			} else {
sawine@5: 				return elem[ name ];
sawine@5: 			}
sawine@5: 		}
sawine@5: 	},
sawine@5: 	
sawine@5: 	propHooks: {
sawine@5: 		tabIndex: {
sawine@5: 			get: function( elem ) {
sawine@5: 				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
sawine@5: 				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
sawine@5: 				var attributeNode = elem.getAttributeNode("tabindex");
sawine@5: 
sawine@5: 				return attributeNode && attributeNode.specified ?
sawine@5: 					parseInt( attributeNode.value, 10 ) :
sawine@5: 					rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
sawine@5: 						0 :
sawine@5: 						undefined;
sawine@5: 			}
sawine@5: 		}
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: // Add the tabindex propHook to attrHooks for back-compat
sawine@5: jQuery.attrHooks.tabIndex = jQuery.propHooks.tabIndex;
sawine@5: 
sawine@5: // Hook for boolean attributes
sawine@5: boolHook = {
sawine@5: 	get: function( elem, name ) {
sawine@5: 		// Align boolean attributes with corresponding properties
sawine@5: 		// Fall back to attribute presence where some booleans are not supported
sawine@5: 		var attrNode;
sawine@5: 		return jQuery.prop( elem, name ) === true || ( attrNode = elem.getAttributeNode( name ) ) && attrNode.nodeValue !== false ?
sawine@5: 			name.toLowerCase() :
sawine@5: 			undefined;
sawine@5: 	},
sawine@5: 	set: function( elem, value, name ) {
sawine@5: 		var propName;
sawine@5: 		if ( value === false ) {
sawine@5: 			// Remove boolean attributes when set to false
sawine@5: 			jQuery.removeAttr( elem, name );
sawine@5: 		} else {
sawine@5: 			// value is true since we know at this point it's type boolean and not false
sawine@5: 			// Set boolean attributes to the same name and set the DOM property
sawine@5: 			propName = jQuery.propFix[ name ] || name;
sawine@5: 			if ( propName in elem ) {
sawine@5: 				// Only set the IDL specifically if it already exists on the element
sawine@5: 				elem[ propName ] = true;
sawine@5: 			}
sawine@5: 
sawine@5: 			elem.setAttribute( name, name.toLowerCase() );
sawine@5: 		}
sawine@5: 		return name;
sawine@5: 	}
sawine@5: };
sawine@5: 
sawine@5: // IE6/7 do not support getting/setting some attributes with get/setAttribute
sawine@5: if ( !jQuery.support.getSetAttribute ) {
sawine@5: 	
sawine@5: 	// Use this for any attribute in IE6/7
sawine@5: 	// This fixes almost every IE6/7 issue
sawine@5: 	nodeHook = jQuery.valHooks.button = {
sawine@5: 		get: function( elem, name ) {
sawine@5: 			var ret;
sawine@5: 			ret = elem.getAttributeNode( name );
sawine@5: 			// Return undefined if nodeValue is empty string
sawine@5: 			return ret && ret.nodeValue !== "" ?
sawine@5: 				ret.nodeValue :
sawine@5: 				undefined;
sawine@5: 		},
sawine@5: 		set: function( elem, value, name ) {
sawine@5: 			// Set the existing or create a new attribute node
sawine@5: 			var ret = elem.getAttributeNode( name );
sawine@5: 			if ( !ret ) {
sawine@5: 				ret = document.createAttribute( name );
sawine@5: 				elem.setAttributeNode( ret );
sawine@5: 			}
sawine@5: 			return (ret.nodeValue = value + "");
sawine@5: 		}
sawine@5: 	};
sawine@5: 
sawine@5: 	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
sawine@5: 	// This is for removals
sawine@5: 	jQuery.each([ "width", "height" ], function( i, name ) {
sawine@5: 		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
sawine@5: 			set: function( elem, value ) {
sawine@5: 				if ( value === "" ) {
sawine@5: 					elem.setAttribute( name, "auto" );
sawine@5: 					return value;
sawine@5: 				}
sawine@5: 			}
sawine@5: 		});
sawine@5: 	});
sawine@5: }
sawine@5: 
sawine@5: 
sawine@5: // Some attributes require a special call on IE
sawine@5: if ( !jQuery.support.hrefNormalized ) {
sawine@5: 	jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
sawine@5: 		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
sawine@5: 			get: function( elem ) {
sawine@5: 				var ret = elem.getAttribute( name, 2 );
sawine@5: 				return ret === null ? undefined : ret;
sawine@5: 			}
sawine@5: 		});
sawine@5: 	});
sawine@5: }
sawine@5: 
sawine@5: if ( !jQuery.support.style ) {
sawine@5: 	jQuery.attrHooks.style = {
sawine@5: 		get: function( elem ) {
sawine@5: 			// Return undefined in the case of empty string
sawine@5: 			// Normalize to lowercase since IE uppercases css property names
sawine@5: 			return elem.style.cssText.toLowerCase() || undefined;
sawine@5: 		},
sawine@5: 		set: function( elem, value ) {
sawine@5: 			return (elem.style.cssText = "" + value);
sawine@5: 		}
sawine@5: 	};
sawine@5: }
sawine@5: 
sawine@5: // Safari mis-reports the default selected property of an option
sawine@5: // Accessing the parent's selectedIndex property fixes it
sawine@5: if ( !jQuery.support.optSelected ) {
sawine@5: 	jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
sawine@5: 		get: function( elem ) {
sawine@5: 			var parent = elem.parentNode;
sawine@5: 
sawine@5: 			if ( parent ) {
sawine@5: 				parent.selectedIndex;
sawine@5: 
sawine@5: 				// Make sure that it also works with optgroups, see #5701
sawine@5: 				if ( parent.parentNode ) {
sawine@5: 					parent.parentNode.selectedIndex;
sawine@5: 				}
sawine@5: 			}
sawine@5: 			return null;
sawine@5: 		}
sawine@5: 	});
sawine@5: }
sawine@5: 
sawine@5: // Radios and checkboxes getter/setter
sawine@5: if ( !jQuery.support.checkOn ) {
sawine@5: 	jQuery.each([ "radio", "checkbox" ], function() {
sawine@5: 		jQuery.valHooks[ this ] = {
sawine@5: 			get: function( elem ) {
sawine@5: 				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
sawine@5: 				return elem.getAttribute("value") === null ? "on" : elem.value;
sawine@5: 			}
sawine@5: 		};
sawine@5: 	});
sawine@5: }
sawine@5: jQuery.each([ "radio", "checkbox" ], function() {
sawine@5: 	jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
sawine@5: 		set: function( elem, value ) {
sawine@5: 			if ( jQuery.isArray( value ) ) {
sawine@5: 				return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0);
sawine@5: 			}
sawine@5: 		}
sawine@5: 	});
sawine@5: });
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: var rnamespaces = /\.(.*)$/,
sawine@5: 	rformElems = /^(?:textarea|input|select)$/i,
sawine@5: 	rperiod = /\./g,
sawine@5: 	rspaces = / /g,
sawine@5: 	rescape = /[^\w\s.|`]/g,
sawine@5: 	fcleanup = function( nm ) {
sawine@5: 		return nm.replace(rescape, "\\$&");
sawine@5: 	};
sawine@5: 
sawine@5: /*
sawine@5:  * A number of helper functions used for managing events.
sawine@5:  * Many of the ideas behind this code originated from
sawine@5:  * Dean Edwards' addEvent library.
sawine@5:  */
sawine@5: jQuery.event = {
sawine@5: 
sawine@5: 	// Bind an event to an element
sawine@5: 	// Original by Dean Edwards
sawine@5: 	add: function( elem, types, handler, data ) {
sawine@5: 		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( handler === false ) {
sawine@5: 			handler = returnFalse;
sawine@5: 		} else if ( !handler ) {
sawine@5: 			// Fixes bug #7229. Fix recommended by jdalton
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		var handleObjIn, handleObj;
sawine@5: 
sawine@5: 		if ( handler.handler ) {
sawine@5: 			handleObjIn = handler;
sawine@5: 			handler = handleObjIn.handler;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Make sure that the function being executed has a unique ID
sawine@5: 		if ( !handler.guid ) {
sawine@5: 			handler.guid = jQuery.guid++;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Init the element's event structure
sawine@5: 		var elemData = jQuery._data( elem );
sawine@5: 
sawine@5: 		// If no elemData is found then we must be trying to bind to one of the
sawine@5: 		// banned noData elements
sawine@5: 		if ( !elemData ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		var events = elemData.events,
sawine@5: 			eventHandle = elemData.handle;
sawine@5: 
sawine@5: 		if ( !events ) {
sawine@5: 			elemData.events = events = {};
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( !eventHandle ) {
sawine@5: 			elemData.handle = eventHandle = function( e ) {
sawine@5: 				// Discard the second event of a jQuery.event.trigger() and
sawine@5: 				// when an event is called after a page has unloaded
sawine@5: 				return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
sawine@5: 					jQuery.event.handle.apply( eventHandle.elem, arguments ) :
sawine@5: 					undefined;
sawine@5: 			};
sawine@5: 		}
sawine@5: 
sawine@5: 		// Add elem as a property of the handle function
sawine@5: 		// This is to prevent a memory leak with non-native events in IE.
sawine@5: 		eventHandle.elem = elem;
sawine@5: 
sawine@5: 		// Handle multiple events separated by a space
sawine@5: 		// jQuery(...).bind("mouseover mouseout", fn);
sawine@5: 		types = types.split(" ");
sawine@5: 
sawine@5: 		var type, i = 0, namespaces;
sawine@5: 
sawine@5: 		while ( (type = types[ i++ ]) ) {
sawine@5: 			handleObj = handleObjIn ?
sawine@5: 				jQuery.extend({}, handleObjIn) :
sawine@5: 				{ handler: handler, data: data };
sawine@5: 
sawine@5: 			// Namespaced event handlers
sawine@5: 			if ( type.indexOf(".") > -1 ) {
sawine@5: 				namespaces = type.split(".");
sawine@5: 				type = namespaces.shift();
sawine@5: 				handleObj.namespace = namespaces.slice(0).sort().join(".");
sawine@5: 
sawine@5: 			} else {
sawine@5: 				namespaces = [];
sawine@5: 				handleObj.namespace = "";
sawine@5: 			}
sawine@5: 
sawine@5: 			handleObj.type = type;
sawine@5: 			if ( !handleObj.guid ) {
sawine@5: 				handleObj.guid = handler.guid;
sawine@5: 			}
sawine@5: 
sawine@5: 			// Get the current list of functions bound to this event
sawine@5: 			var handlers = events[ type ],
sawine@5: 				special = jQuery.event.special[ type ] || {};
sawine@5: 
sawine@5: 			// Init the event handler queue
sawine@5: 			if ( !handlers ) {
sawine@5: 				handlers = events[ type ] = [];
sawine@5: 
sawine@5: 				// Check for a special event handler
sawine@5: 				// Only use addEventListener/attachEvent if the special
sawine@5: 				// events handler returns false
sawine@5: 				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
sawine@5: 					// Bind the global event handler to the element
sawine@5: 					if ( elem.addEventListener ) {
sawine@5: 						elem.addEventListener( type, eventHandle, false );
sawine@5: 
sawine@5: 					} else if ( elem.attachEvent ) {
sawine@5: 						elem.attachEvent( "on" + type, eventHandle );
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( special.add ) {
sawine@5: 				special.add.call( elem, handleObj );
sawine@5: 
sawine@5: 				if ( !handleObj.handler.guid ) {
sawine@5: 					handleObj.handler.guid = handler.guid;
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			// Add the function to the element's handler list
sawine@5: 			handlers.push( handleObj );
sawine@5: 
sawine@5: 			// Keep track of which events have been used, for event optimization
sawine@5: 			jQuery.event.global[ type ] = true;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Nullify elem to prevent memory leaks in IE
sawine@5: 		elem = null;
sawine@5: 	},
sawine@5: 
sawine@5: 	global: {},
sawine@5: 
sawine@5: 	// Detach an event or set of events from an element
sawine@5: 	remove: function( elem, types, handler, pos ) {
sawine@5: 		// don't do events on text and comment nodes
sawine@5: 		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( handler === false ) {
sawine@5: 			handler = returnFalse;
sawine@5: 		}
sawine@5: 
sawine@5: 		var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
sawine@5: 			elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
sawine@5: 			events = elemData && elemData.events;
sawine@5: 
sawine@5: 		if ( !elemData || !events ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		// types is actually an event object here
sawine@5: 		if ( types && types.type ) {
sawine@5: 			handler = types.handler;
sawine@5: 			types = types.type;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Unbind all events for the element
sawine@5: 		if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
sawine@5: 			types = types || "";
sawine@5: 
sawine@5: 			for ( type in events ) {
sawine@5: 				jQuery.event.remove( elem, type + types );
sawine@5: 			}
sawine@5: 
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Handle multiple events separated by a space
sawine@5: 		// jQuery(...).unbind("mouseover mouseout", fn);
sawine@5: 		types = types.split(" ");
sawine@5: 
sawine@5: 		while ( (type = types[ i++ ]) ) {
sawine@5: 			origType = type;
sawine@5: 			handleObj = null;
sawine@5: 			all = type.indexOf(".") < 0;
sawine@5: 			namespaces = [];
sawine@5: 
sawine@5: 			if ( !all ) {
sawine@5: 				// Namespaced event handlers
sawine@5: 				namespaces = type.split(".");
sawine@5: 				type = namespaces.shift();
sawine@5: 
sawine@5: 				namespace = new RegExp("(^|\\.)" +
sawine@5: 					jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
sawine@5: 			}
sawine@5: 
sawine@5: 			eventType = events[ type ];
sawine@5: 
sawine@5: 			if ( !eventType ) {
sawine@5: 				continue;
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( !handler ) {
sawine@5: 				for ( j = 0; j < eventType.length; j++ ) {
sawine@5: 					handleObj = eventType[ j ];
sawine@5: 
sawine@5: 					if ( all || namespace.test( handleObj.namespace ) ) {
sawine@5: 						jQuery.event.remove( elem, origType, handleObj.handler, j );
sawine@5: 						eventType.splice( j--, 1 );
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				continue;
sawine@5: 			}
sawine@5: 
sawine@5: 			special = jQuery.event.special[ type ] || {};
sawine@5: 
sawine@5: 			for ( j = pos || 0; j < eventType.length; j++ ) {
sawine@5: 				handleObj = eventType[ j ];
sawine@5: 
sawine@5: 				if ( handler.guid === handleObj.guid ) {
sawine@5: 					// remove the given handler for the given type
sawine@5: 					if ( all || namespace.test( handleObj.namespace ) ) {
sawine@5: 						if ( pos == null ) {
sawine@5: 							eventType.splice( j--, 1 );
sawine@5: 						}
sawine@5: 
sawine@5: 						if ( special.remove ) {
sawine@5: 							special.remove.call( elem, handleObj );
sawine@5: 						}
sawine@5: 					}
sawine@5: 
sawine@5: 					if ( pos != null ) {
sawine@5: 						break;
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			// remove generic event handler if no more handlers exist
sawine@5: 			if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
sawine@5: 				if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
sawine@5: 					jQuery.removeEvent( elem, type, elemData.handle );
sawine@5: 				}
sawine@5: 
sawine@5: 				ret = null;
sawine@5: 				delete events[ type ];
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		// Remove the expando if it's no longer used
sawine@5: 		if ( jQuery.isEmptyObject( events ) ) {
sawine@5: 			var handle = elemData.handle;
sawine@5: 			if ( handle ) {
sawine@5: 				handle.elem = null;
sawine@5: 			}
sawine@5: 
sawine@5: 			delete elemData.events;
sawine@5: 			delete elemData.handle;
sawine@5: 
sawine@5: 			if ( jQuery.isEmptyObject( elemData ) ) {
sawine@5: 				jQuery.removeData( elem, undefined, true );
sawine@5: 			}
sawine@5: 		}
sawine@5: 	},
sawine@5: 	
sawine@5: 	// Events that are safe to short-circuit if no handlers are attached.
sawine@5: 	// Native DOM events should not be added, they may have inline handlers.
sawine@5: 	customEvent: {
sawine@5: 		"getData": true,
sawine@5: 		"setData": true,
sawine@5: 		"changeData": true
sawine@5: 	},
sawine@5: 
sawine@5: 	trigger: function( event, data, elem, onlyHandlers ) {
sawine@5: 		// Event object or event type
sawine@5: 		var type = event.type || event,
sawine@5: 			namespaces = [],
sawine@5: 			exclusive;
sawine@5: 
sawine@5: 		if ( type.indexOf("!") >= 0 ) {
sawine@5: 			// Exclusive events trigger only for the exact event (no namespaces)
sawine@5: 			type = type.slice(0, -1);
sawine@5: 			exclusive = true;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( type.indexOf(".") >= 0 ) {
sawine@5: 			// Namespaced trigger; create a regexp to match event type in handle()
sawine@5: 			namespaces = type.split(".");
sawine@5: 			type = namespaces.shift();
sawine@5: 			namespaces.sort();
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
sawine@5: 			// No jQuery handlers for this event type, and it can't have inline handlers
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Caller can pass in an Event, Object, or just an event type string
sawine@5: 		event = typeof event === "object" ?
sawine@5: 			// jQuery.Event object
sawine@5: 			event[ jQuery.expando ] ? event :
sawine@5: 			// Object literal
sawine@5: 			new jQuery.Event( type, event ) :
sawine@5: 			// Just the event type (string)
sawine@5: 			new jQuery.Event( type );
sawine@5: 
sawine@5: 		event.type = type;
sawine@5: 		event.exclusive = exclusive;
sawine@5: 		event.namespace = namespaces.join(".");
sawine@5: 		event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)");
sawine@5: 		
sawine@5: 		// triggerHandler() and global events don't bubble or run the default action
sawine@5: 		if ( onlyHandlers || !elem ) {
sawine@5: 			event.preventDefault();
sawine@5: 			event.stopPropagation();
sawine@5: 		}
sawine@5: 
sawine@5: 		// Handle a global trigger
sawine@5: 		if ( !elem ) {
sawine@5: 			// TODO: Stop taunting the data cache; remove global events and always attach to document
sawine@5: 			jQuery.each( jQuery.cache, function() {
sawine@5: 				// internalKey variable is just used to make it easier to find
sawine@5: 				// and potentially change this stuff later; currently it just
sawine@5: 				// points to jQuery.expando
sawine@5: 				var internalKey = jQuery.expando,
sawine@5: 					internalCache = this[ internalKey ];
sawine@5: 				if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
sawine@5: 					jQuery.event.trigger( event, data, internalCache.handle.elem );
sawine@5: 				}
sawine@5: 			});
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Don't do events on text and comment nodes
sawine@5: 		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Clean up the event in case it is being reused
sawine@5: 		event.result = undefined;
sawine@5: 		event.target = elem;
sawine@5: 
sawine@5: 		// Clone any incoming data and prepend the event, creating the handler arg list
sawine@5: 		data = data != null ? jQuery.makeArray( data ) : [];
sawine@5: 		data.unshift( event );
sawine@5: 
sawine@5: 		var cur = elem,
sawine@5: 			// IE doesn't like method names with a colon (#3533, #8272)
sawine@5: 			ontype = type.indexOf(":") < 0 ? "on" + type : "";
sawine@5: 
sawine@5: 		// Fire event on the current element, then bubble up the DOM tree
sawine@5: 		do {
sawine@5: 			var handle = jQuery._data( cur, "handle" );
sawine@5: 
sawine@5: 			event.currentTarget = cur;
sawine@5: 			if ( handle ) {
sawine@5: 				handle.apply( cur, data );
sawine@5: 			}
sawine@5: 
sawine@5: 			// Trigger an inline bound script
sawine@5: 			if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) {
sawine@5: 				event.result = false;
sawine@5: 				event.preventDefault();
sawine@5: 			}
sawine@5: 
sawine@5: 			// Bubble up to document, then to window
sawine@5: 			cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window;
sawine@5: 		} while ( cur && !event.isPropagationStopped() );
sawine@5: 
sawine@5: 		// If nobody prevented the default action, do it now
sawine@5: 		if ( !event.isDefaultPrevented() ) {
sawine@5: 			var old,
sawine@5: 				special = jQuery.event.special[ type ] || {};
sawine@5: 
sawine@5: 			if ( (!special._default || special._default.call( elem.ownerDocument, event ) === false) &&
sawine@5: 				!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
sawine@5: 
sawine@5: 				// Call a native DOM method on the target with the same name name as the event.
sawine@5: 				// Can't use an .isFunction)() check here because IE6/7 fails that test.
sawine@5: 				// IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch.
sawine@5: 				try {
sawine@5: 					if ( ontype && elem[ type ] ) {
sawine@5: 						// Don't re-trigger an onFOO event when we call its FOO() method
sawine@5: 						old = elem[ ontype ];
sawine@5: 
sawine@5: 						if ( old ) {
sawine@5: 							elem[ ontype ] = null;
sawine@5: 						}
sawine@5: 
sawine@5: 						jQuery.event.triggered = type;
sawine@5: 						elem[ type ]();
sawine@5: 					}
sawine@5: 				} catch ( ieError ) {}
sawine@5: 
sawine@5: 				if ( old ) {
sawine@5: 					elem[ ontype ] = old;
sawine@5: 				}
sawine@5: 
sawine@5: 				jQuery.event.triggered = undefined;
sawine@5: 			}
sawine@5: 		}
sawine@5: 		
sawine@5: 		return event.result;
sawine@5: 	},
sawine@5: 
sawine@5: 	handle: function( event ) {
sawine@5: 		event = jQuery.event.fix( event || window.event );
sawine@5: 		// Snapshot the handlers list since a called handler may add/remove events.
sawine@5: 		var handlers = ((jQuery._data( this, "events" ) || {})[ event.type ] || []).slice(0),
sawine@5: 			run_all = !event.exclusive && !event.namespace,
sawine@5: 			args = Array.prototype.slice.call( arguments, 0 );
sawine@5: 
sawine@5: 		// Use the fix-ed Event rather than the (read-only) native event
sawine@5: 		args[0] = event;
sawine@5: 		event.currentTarget = this;
sawine@5: 
sawine@5: 		for ( var j = 0, l = handlers.length; j < l; j++ ) {
sawine@5: 			var handleObj = handlers[ j ];
sawine@5: 
sawine@5: 			// Triggered event must 1) be non-exclusive and have no namespace, or
sawine@5: 			// 2) have namespace(s) a subset or equal to those in the bound event.
sawine@5: 			if ( run_all || event.namespace_re.test( handleObj.namespace ) ) {
sawine@5: 				// Pass in a reference to the handler function itself
sawine@5: 				// So that we can later remove it
sawine@5: 				event.handler = handleObj.handler;
sawine@5: 				event.data = handleObj.data;
sawine@5: 				event.handleObj = handleObj;
sawine@5: 
sawine@5: 				var ret = handleObj.handler.apply( this, args );
sawine@5: 
sawine@5: 				if ( ret !== undefined ) {
sawine@5: 					event.result = ret;
sawine@5: 					if ( ret === false ) {
sawine@5: 						event.preventDefault();
sawine@5: 						event.stopPropagation();
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( event.isImmediatePropagationStopped() ) {
sawine@5: 					break;
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 		return event.result;
sawine@5: 	},
sawine@5: 
sawine@5: 	props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
sawine@5: 
sawine@5: 	fix: function( event ) {
sawine@5: 		if ( event[ jQuery.expando ] ) {
sawine@5: 			return event;
sawine@5: 		}
sawine@5: 
sawine@5: 		// store a copy of the original event object
sawine@5: 		// and "clone" to set read-only properties
sawine@5: 		var originalEvent = event;
sawine@5: 		event = jQuery.Event( originalEvent );
sawine@5: 
sawine@5: 		for ( var i = this.props.length, prop; i; ) {
sawine@5: 			prop = this.props[ --i ];
sawine@5: 			event[ prop ] = originalEvent[ prop ];
sawine@5: 		}
sawine@5: 
sawine@5: 		// Fix target property, if necessary
sawine@5: 		if ( !event.target ) {
sawine@5: 			// Fixes #1925 where srcElement might not be defined either
sawine@5: 			event.target = event.srcElement || document;
sawine@5: 		}
sawine@5: 
sawine@5: 		// check if target is a textnode (safari)
sawine@5: 		if ( event.target.nodeType === 3 ) {
sawine@5: 			event.target = event.target.parentNode;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Add relatedTarget, if necessary
sawine@5: 		if ( !event.relatedTarget && event.fromElement ) {
sawine@5: 			event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Calculate pageX/Y if missing and clientX/Y available
sawine@5: 		if ( event.pageX == null && event.clientX != null ) {
sawine@5: 			var eventDocument = event.target.ownerDocument || document,
sawine@5: 				doc = eventDocument.documentElement,
sawine@5: 				body = eventDocument.body;
sawine@5: 
sawine@5: 			event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
sawine@5: 			event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
sawine@5: 		}
sawine@5: 
sawine@5: 		// Add which for key events
sawine@5: 		if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
sawine@5: 			event.which = event.charCode != null ? event.charCode : event.keyCode;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
sawine@5: 		if ( !event.metaKey && event.ctrlKey ) {
sawine@5: 			event.metaKey = event.ctrlKey;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Add which for click: 1 === left; 2 === middle; 3 === right
sawine@5: 		// Note: button is not normalized, so don't use it
sawine@5: 		if ( !event.which && event.button !== undefined ) {
sawine@5: 			event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
sawine@5: 		}
sawine@5: 
sawine@5: 		return event;
sawine@5: 	},
sawine@5: 
sawine@5: 	// Deprecated, use jQuery.guid instead
sawine@5: 	guid: 1E8,
sawine@5: 
sawine@5: 	// Deprecated, use jQuery.proxy instead
sawine@5: 	proxy: jQuery.proxy,
sawine@5: 
sawine@5: 	special: {
sawine@5: 		ready: {
sawine@5: 			// Make sure the ready event is setup
sawine@5: 			setup: jQuery.bindReady,
sawine@5: 			teardown: jQuery.noop
sawine@5: 		},
sawine@5: 
sawine@5: 		live: {
sawine@5: 			add: function( handleObj ) {
sawine@5: 				jQuery.event.add( this,
sawine@5: 					liveConvert( handleObj.origType, handleObj.selector ),
sawine@5: 					jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
sawine@5: 			},
sawine@5: 
sawine@5: 			remove: function( handleObj ) {
sawine@5: 				jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
sawine@5: 			}
sawine@5: 		},
sawine@5: 
sawine@5: 		beforeunload: {
sawine@5: 			setup: function( data, namespaces, eventHandle ) {
sawine@5: 				// We only want to do this special case on windows
sawine@5: 				if ( jQuery.isWindow( this ) ) {
sawine@5: 					this.onbeforeunload = eventHandle;
sawine@5: 				}
sawine@5: 			},
sawine@5: 
sawine@5: 			teardown: function( namespaces, eventHandle ) {
sawine@5: 				if ( this.onbeforeunload === eventHandle ) {
sawine@5: 					this.onbeforeunload = null;
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 	}
sawine@5: };
sawine@5: 
sawine@5: jQuery.removeEvent = document.removeEventListener ?
sawine@5: 	function( elem, type, handle ) {
sawine@5: 		if ( elem.removeEventListener ) {
sawine@5: 			elem.removeEventListener( type, handle, false );
sawine@5: 		}
sawine@5: 	} :
sawine@5: 	function( elem, type, handle ) {
sawine@5: 		if ( elem.detachEvent ) {
sawine@5: 			elem.detachEvent( "on" + type, handle );
sawine@5: 		}
sawine@5: 	};
sawine@5: 
sawine@5: jQuery.Event = function( src, props ) {
sawine@5: 	// Allow instantiation without the 'new' keyword
sawine@5: 	if ( !this.preventDefault ) {
sawine@5: 		return new jQuery.Event( src, props );
sawine@5: 	}
sawine@5: 
sawine@5: 	// Event object
sawine@5: 	if ( src && src.type ) {
sawine@5: 		this.originalEvent = src;
sawine@5: 		this.type = src.type;
sawine@5: 
sawine@5: 		// Events bubbling up the document may have been marked as prevented
sawine@5: 		// by a handler lower down the tree; reflect the correct value.
sawine@5: 		this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
sawine@5: 			src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
sawine@5: 
sawine@5: 	// Event type
sawine@5: 	} else {
sawine@5: 		this.type = src;
sawine@5: 	}
sawine@5: 
sawine@5: 	// Put explicitly provided properties onto the event object
sawine@5: 	if ( props ) {
sawine@5: 		jQuery.extend( this, props );
sawine@5: 	}
sawine@5: 
sawine@5: 	// timeStamp is buggy for some events on Firefox(#3843)
sawine@5: 	// So we won't rely on the native value
sawine@5: 	this.timeStamp = jQuery.now();
sawine@5: 
sawine@5: 	// Mark it as fixed
sawine@5: 	this[ jQuery.expando ] = true;
sawine@5: };
sawine@5: 
sawine@5: function returnFalse() {
sawine@5: 	return false;
sawine@5: }
sawine@5: function returnTrue() {
sawine@5: 	return true;
sawine@5: }
sawine@5: 
sawine@5: // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
sawine@5: // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
sawine@5: jQuery.Event.prototype = {
sawine@5: 	preventDefault: function() {
sawine@5: 		this.isDefaultPrevented = returnTrue;
sawine@5: 
sawine@5: 		var e = this.originalEvent;
sawine@5: 		if ( !e ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		// if preventDefault exists run it on the original event
sawine@5: 		if ( e.preventDefault ) {
sawine@5: 			e.preventDefault();
sawine@5: 
sawine@5: 		// otherwise set the returnValue property of the original event to false (IE)
sawine@5: 		} else {
sawine@5: 			e.returnValue = false;
sawine@5: 		}
sawine@5: 	},
sawine@5: 	stopPropagation: function() {
sawine@5: 		this.isPropagationStopped = returnTrue;
sawine@5: 
sawine@5: 		var e = this.originalEvent;
sawine@5: 		if ( !e ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 		// if stopPropagation exists run it on the original event
sawine@5: 		if ( e.stopPropagation ) {
sawine@5: 			e.stopPropagation();
sawine@5: 		}
sawine@5: 		// otherwise set the cancelBubble property of the original event to true (IE)
sawine@5: 		e.cancelBubble = true;
sawine@5: 	},
sawine@5: 	stopImmediatePropagation: function() {
sawine@5: 		this.isImmediatePropagationStopped = returnTrue;
sawine@5: 		this.stopPropagation();
sawine@5: 	},
sawine@5: 	isDefaultPrevented: returnFalse,
sawine@5: 	isPropagationStopped: returnFalse,
sawine@5: 	isImmediatePropagationStopped: returnFalse
sawine@5: };
sawine@5: 
sawine@5: // Checks if an event happened on an element within another element
sawine@5: // Used in jQuery.event.special.mouseenter and mouseleave handlers
sawine@5: var withinElement = function( event ) {
sawine@5: 
sawine@5: 	// Check if mouse(over|out) are still within the same parent element
sawine@5: 	var related = event.relatedTarget,
sawine@5: 		inside = false,
sawine@5: 		eventType = event.type;
sawine@5: 
sawine@5: 	event.type = event.data;
sawine@5: 
sawine@5: 	if ( related !== this ) {
sawine@5: 
sawine@5: 		if ( related ) {
sawine@5: 			inside = jQuery.contains( this, related );
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( !inside ) {
sawine@5: 
sawine@5: 			jQuery.event.handle.apply( this, arguments );
sawine@5: 
sawine@5: 			event.type = eventType;
sawine@5: 		}
sawine@5: 	}
sawine@5: },
sawine@5: 
sawine@5: // In case of event delegation, we only need to rename the event.type,
sawine@5: // liveHandler will take care of the rest.
sawine@5: delegate = function( event ) {
sawine@5: 	event.type = event.data;
sawine@5: 	jQuery.event.handle.apply( this, arguments );
sawine@5: };
sawine@5: 
sawine@5: // Create mouseenter and mouseleave events
sawine@5: jQuery.each({
sawine@5: 	mouseenter: "mouseover",
sawine@5: 	mouseleave: "mouseout"
sawine@5: }, function( orig, fix ) {
sawine@5: 	jQuery.event.special[ orig ] = {
sawine@5: 		setup: function( data ) {
sawine@5: 			jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
sawine@5: 		},
sawine@5: 		teardown: function( data ) {
sawine@5: 			jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
sawine@5: 		}
sawine@5: 	};
sawine@5: });
sawine@5: 
sawine@5: // submit delegation
sawine@5: if ( !jQuery.support.submitBubbles ) {
sawine@5: 
sawine@5: 	jQuery.event.special.submit = {
sawine@5: 		setup: function( data, namespaces ) {
sawine@5: 			if ( !jQuery.nodeName( this, "form" ) ) {
sawine@5: 				jQuery.event.add(this, "click.specialSubmit", function( e ) {
sawine@5: 					// Avoid triggering error on non-existent type attribute in IE VML (#7071)
sawine@5: 					var elem = e.target,
sawine@5: 						type = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.type : "";
sawine@5: 
sawine@5: 					if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
sawine@5: 						trigger( "submit", this, arguments );
sawine@5: 					}
sawine@5: 				});
sawine@5: 
sawine@5: 				jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
sawine@5: 					var elem = e.target,
sawine@5: 						type = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.type : "";
sawine@5: 
sawine@5: 					if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
sawine@5: 						trigger( "submit", this, arguments );
sawine@5: 					}
sawine@5: 				});
sawine@5: 
sawine@5: 			} else {
sawine@5: 				return false;
sawine@5: 			}
sawine@5: 		},
sawine@5: 
sawine@5: 		teardown: function( namespaces ) {
sawine@5: 			jQuery.event.remove( this, ".specialSubmit" );
sawine@5: 		}
sawine@5: 	};
sawine@5: 
sawine@5: }
sawine@5: 
sawine@5: // change delegation, happens here so we have bind.
sawine@5: if ( !jQuery.support.changeBubbles ) {
sawine@5: 
sawine@5: 	var changeFilters,
sawine@5: 
sawine@5: 	getVal = function( elem ) {
sawine@5: 		var type = jQuery.nodeName( elem, "input" ) ? elem.type : "",
sawine@5: 			val = elem.value;
sawine@5: 
sawine@5: 		if ( type === "radio" || type === "checkbox" ) {
sawine@5: 			val = elem.checked;
sawine@5: 
sawine@5: 		} else if ( type === "select-multiple" ) {
sawine@5: 			val = elem.selectedIndex > -1 ?
sawine@5: 				jQuery.map( elem.options, function( elem ) {
sawine@5: 					return elem.selected;
sawine@5: 				}).join("-") :
sawine@5: 				"";
sawine@5: 
sawine@5: 		} else if ( jQuery.nodeName( elem, "select" ) ) {
sawine@5: 			val = elem.selectedIndex;
sawine@5: 		}
sawine@5: 
sawine@5: 		return val;
sawine@5: 	},
sawine@5: 
sawine@5: 	testChange = function testChange( e ) {
sawine@5: 		var elem = e.target, data, val;
sawine@5: 
sawine@5: 		if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		data = jQuery._data( elem, "_change_data" );
sawine@5: 		val = getVal(elem);
sawine@5: 
sawine@5: 		// the current data will be also retrieved by beforeactivate
sawine@5: 		if ( e.type !== "focusout" || elem.type !== "radio" ) {
sawine@5: 			jQuery._data( elem, "_change_data", val );
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( data === undefined || val === data ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( data != null || val ) {
sawine@5: 			e.type = "change";
sawine@5: 			e.liveFired = undefined;
sawine@5: 			jQuery.event.trigger( e, arguments[1], elem );
sawine@5: 		}
sawine@5: 	};
sawine@5: 
sawine@5: 	jQuery.event.special.change = {
sawine@5: 		filters: {
sawine@5: 			focusout: testChange,
sawine@5: 
sawine@5: 			beforedeactivate: testChange,
sawine@5: 
sawine@5: 			click: function( e ) {
sawine@5: 				var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
sawine@5: 
sawine@5: 				if ( type === "radio" || type === "checkbox" || jQuery.nodeName( elem, "select" ) ) {
sawine@5: 					testChange.call( this, e );
sawine@5: 				}
sawine@5: 			},
sawine@5: 
sawine@5: 			// Change has to be called before submit
sawine@5: 			// Keydown will be called before keypress, which is used in submit-event delegation
sawine@5: 			keydown: function( e ) {
sawine@5: 				var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
sawine@5: 
sawine@5: 				if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) ||
sawine@5: 					(e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
sawine@5: 					type === "select-multiple" ) {
sawine@5: 					testChange.call( this, e );
sawine@5: 				}
sawine@5: 			},
sawine@5: 
sawine@5: 			// Beforeactivate happens also before the previous element is blurred
sawine@5: 			// with this event you can't trigger a change event, but you can store
sawine@5: 			// information
sawine@5: 			beforeactivate: function( e ) {
sawine@5: 				var elem = e.target;
sawine@5: 				jQuery._data( elem, "_change_data", getVal(elem) );
sawine@5: 			}
sawine@5: 		},
sawine@5: 
sawine@5: 		setup: function( data, namespaces ) {
sawine@5: 			if ( this.type === "file" ) {
sawine@5: 				return false;
sawine@5: 			}
sawine@5: 
sawine@5: 			for ( var type in changeFilters ) {
sawine@5: 				jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
sawine@5: 			}
sawine@5: 
sawine@5: 			return rformElems.test( this.nodeName );
sawine@5: 		},
sawine@5: 
sawine@5: 		teardown: function( namespaces ) {
sawine@5: 			jQuery.event.remove( this, ".specialChange" );
sawine@5: 
sawine@5: 			return rformElems.test( this.nodeName );
sawine@5: 		}
sawine@5: 	};
sawine@5: 
sawine@5: 	changeFilters = jQuery.event.special.change.filters;
sawine@5: 
sawine@5: 	// Handle when the input is .focus()'d
sawine@5: 	changeFilters.focus = changeFilters.beforeactivate;
sawine@5: }
sawine@5: 
sawine@5: function trigger( type, elem, args ) {
sawine@5: 	// Piggyback on a donor event to simulate a different one.
sawine@5: 	// Fake originalEvent to avoid donor's stopPropagation, but if the
sawine@5: 	// simulated event prevents default then we do the same on the donor.
sawine@5: 	// Don't pass args or remember liveFired; they apply to the donor event.
sawine@5: 	var event = jQuery.extend( {}, args[ 0 ] );
sawine@5: 	event.type = type;
sawine@5: 	event.originalEvent = {};
sawine@5: 	event.liveFired = undefined;
sawine@5: 	jQuery.event.handle.call( elem, event );
sawine@5: 	if ( event.isDefaultPrevented() ) {
sawine@5: 		args[ 0 ].preventDefault();
sawine@5: 	}
sawine@5: }
sawine@5: 
sawine@5: // Create "bubbling" focus and blur events
sawine@5: if ( !jQuery.support.focusinBubbles ) {
sawine@5: 	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
sawine@5: 
sawine@5: 		// Attach a single capturing handler while someone wants focusin/focusout
sawine@5: 		var attaches = 0;
sawine@5: 
sawine@5: 		jQuery.event.special[ fix ] = {
sawine@5: 			setup: function() {
sawine@5: 				if ( attaches++ === 0 ) {
sawine@5: 					document.addEventListener( orig, handler, true );
sawine@5: 				}
sawine@5: 			},
sawine@5: 			teardown: function() {
sawine@5: 				if ( --attaches === 0 ) {
sawine@5: 					document.removeEventListener( orig, handler, true );
sawine@5: 				}
sawine@5: 			}
sawine@5: 		};
sawine@5: 
sawine@5: 		function handler( donor ) {
sawine@5: 			// Donor event is always a native one; fix it and switch its type.
sawine@5: 			// Let focusin/out handler cancel the donor focus/blur event.
sawine@5: 			var e = jQuery.event.fix( donor );
sawine@5: 			e.type = fix;
sawine@5: 			e.originalEvent = {};
sawine@5: 			jQuery.event.trigger( e, null, e.target );
sawine@5: 			if ( e.isDefaultPrevented() ) {
sawine@5: 				donor.preventDefault();
sawine@5: 			}
sawine@5: 		}
sawine@5: 	});
sawine@5: }
sawine@5: 
sawine@5: jQuery.each(["bind", "one"], function( i, name ) {
sawine@5: 	jQuery.fn[ name ] = function( type, data, fn ) {
sawine@5: 		var handler;
sawine@5: 
sawine@5: 		// Handle object literals
sawine@5: 		if ( typeof type === "object" ) {
sawine@5: 			for ( var key in type ) {
sawine@5: 				this[ name ](key, data, type[key], fn);
sawine@5: 			}
sawine@5: 			return this;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( arguments.length === 2 || data === false ) {
sawine@5: 			fn = data;
sawine@5: 			data = undefined;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( name === "one" ) {
sawine@5: 			handler = function( event ) {
sawine@5: 				jQuery( this ).unbind( event, handler );
sawine@5: 				return fn.apply( this, arguments );
sawine@5: 			};
sawine@5: 			handler.guid = fn.guid || jQuery.guid++;
sawine@5: 		} else {
sawine@5: 			handler = fn;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( type === "unload" && name !== "one" ) {
sawine@5: 			this.one( type, data, fn );
sawine@5: 
sawine@5: 		} else {
sawine@5: 			for ( var i = 0, l = this.length; i < l; i++ ) {
sawine@5: 				jQuery.event.add( this[i], type, handler, data );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return this;
sawine@5: 	};
sawine@5: });
sawine@5: 
sawine@5: jQuery.fn.extend({
sawine@5: 	unbind: function( type, fn ) {
sawine@5: 		// Handle object literals
sawine@5: 		if ( typeof type === "object" && !type.preventDefault ) {
sawine@5: 			for ( var key in type ) {
sawine@5: 				this.unbind(key, type[key]);
sawine@5: 			}
sawine@5: 
sawine@5: 		} else {
sawine@5: 			for ( var i = 0, l = this.length; i < l; i++ ) {
sawine@5: 				jQuery.event.remove( this[i], type, fn );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return this;
sawine@5: 	},
sawine@5: 
sawine@5: 	delegate: function( selector, types, data, fn ) {
sawine@5: 		return this.live( types, data, fn, selector );
sawine@5: 	},
sawine@5: 
sawine@5: 	undelegate: function( selector, types, fn ) {
sawine@5: 		if ( arguments.length === 0 ) {
sawine@5: 			return this.unbind( "live" );
sawine@5: 
sawine@5: 		} else {
sawine@5: 			return this.die( types, null, fn, selector );
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	trigger: function( type, data ) {
sawine@5: 		return this.each(function() {
sawine@5: 			jQuery.event.trigger( type, data, this );
sawine@5: 		});
sawine@5: 	},
sawine@5: 
sawine@5: 	triggerHandler: function( type, data ) {
sawine@5: 		if ( this[0] ) {
sawine@5: 			return jQuery.event.trigger( type, data, this[0], true );
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	toggle: function( fn ) {
sawine@5: 		// Save reference to arguments for access in closure
sawine@5: 		var args = arguments,
sawine@5: 			guid = fn.guid || jQuery.guid++,
sawine@5: 			i = 0,
sawine@5: 			toggler = function( event ) {
sawine@5: 				// Figure out which function to execute
sawine@5: 				var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
sawine@5: 				jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
sawine@5: 
sawine@5: 				// Make sure that clicks stop
sawine@5: 				event.preventDefault();
sawine@5: 
sawine@5: 				// and execute the function
sawine@5: 				return args[ lastToggle ].apply( this, arguments ) || false;
sawine@5: 			};
sawine@5: 
sawine@5: 		// link all the functions, so any of them can unbind this click handler
sawine@5: 		toggler.guid = guid;
sawine@5: 		while ( i < args.length ) {
sawine@5: 			args[ i++ ].guid = guid;
sawine@5: 		}
sawine@5: 
sawine@5: 		return this.click( toggler );
sawine@5: 	},
sawine@5: 
sawine@5: 	hover: function( fnOver, fnOut ) {
sawine@5: 		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: var liveMap = {
sawine@5: 	focus: "focusin",
sawine@5: 	blur: "focusout",
sawine@5: 	mouseenter: "mouseover",
sawine@5: 	mouseleave: "mouseout"
sawine@5: };
sawine@5: 
sawine@5: jQuery.each(["live", "die"], function( i, name ) {
sawine@5: 	jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
sawine@5: 		var type, i = 0, match, namespaces, preType,
sawine@5: 			selector = origSelector || this.selector,
sawine@5: 			context = origSelector ? this : jQuery( this.context );
sawine@5: 
sawine@5: 		if ( typeof types === "object" && !types.preventDefault ) {
sawine@5: 			for ( var key in types ) {
sawine@5: 				context[ name ]( key, data, types[key], selector );
sawine@5: 			}
sawine@5: 
sawine@5: 			return this;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( name === "die" && !types &&
sawine@5: 					origSelector && origSelector.charAt(0) === "." ) {
sawine@5: 
sawine@5: 			context.unbind( origSelector );
sawine@5: 
sawine@5: 			return this;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( data === false || jQuery.isFunction( data ) ) {
sawine@5: 			fn = data || returnFalse;
sawine@5: 			data = undefined;
sawine@5: 		}
sawine@5: 
sawine@5: 		types = (types || "").split(" ");
sawine@5: 
sawine@5: 		while ( (type = types[ i++ ]) != null ) {
sawine@5: 			match = rnamespaces.exec( type );
sawine@5: 			namespaces = "";
sawine@5: 
sawine@5: 			if ( match )  {
sawine@5: 				namespaces = match[0];
sawine@5: 				type = type.replace( rnamespaces, "" );
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( type === "hover" ) {
sawine@5: 				types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
sawine@5: 				continue;
sawine@5: 			}
sawine@5: 
sawine@5: 			preType = type;
sawine@5: 
sawine@5: 			if ( liveMap[ type ] ) {
sawine@5: 				types.push( liveMap[ type ] + namespaces );
sawine@5: 				type = type + namespaces;
sawine@5: 
sawine@5: 			} else {
sawine@5: 				type = (liveMap[ type ] || type) + namespaces;
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( name === "live" ) {
sawine@5: 				// bind live handler
sawine@5: 				for ( var j = 0, l = context.length; j < l; j++ ) {
sawine@5: 					jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
sawine@5: 						{ data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
sawine@5: 				}
sawine@5: 
sawine@5: 			} else {
sawine@5: 				// unbind live handler
sawine@5: 				context.unbind( "live." + liveConvert( type, selector ), fn );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return this;
sawine@5: 	};
sawine@5: });
sawine@5: 
sawine@5: function liveHandler( event ) {
sawine@5: 	var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
sawine@5: 		elems = [],
sawine@5: 		selectors = [],
sawine@5: 		events = jQuery._data( this, "events" );
sawine@5: 
sawine@5: 	// Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
sawine@5: 	if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
sawine@5: 		return;
sawine@5: 	}
sawine@5: 
sawine@5: 	if ( event.namespace ) {
sawine@5: 		namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
sawine@5: 	}
sawine@5: 
sawine@5: 	event.liveFired = this;
sawine@5: 
sawine@5: 	var live = events.live.slice(0);
sawine@5: 
sawine@5: 	for ( j = 0; j < live.length; j++ ) {
sawine@5: 		handleObj = live[j];
sawine@5: 
sawine@5: 		if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
sawine@5: 			selectors.push( handleObj.selector );
sawine@5: 
sawine@5: 		} else {
sawine@5: 			live.splice( j--, 1 );
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	match = jQuery( event.target ).closest( selectors, event.currentTarget );
sawine@5: 
sawine@5: 	for ( i = 0, l = match.length; i < l; i++ ) {
sawine@5: 		close = match[i];
sawine@5: 
sawine@5: 		for ( j = 0; j < live.length; j++ ) {
sawine@5: 			handleObj = live[j];
sawine@5: 
sawine@5: 			if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) && !close.elem.disabled ) {
sawine@5: 				elem = close.elem;
sawine@5: 				related = null;
sawine@5: 
sawine@5: 				// Those two events require additional checking
sawine@5: 				if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
sawine@5: 					event.type = handleObj.preType;
sawine@5: 					related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
sawine@5: 
sawine@5: 					// Make sure not to accidentally match a child element with the same selector
sawine@5: 					if ( related && jQuery.contains( elem, related ) ) {
sawine@5: 						related = elem;
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( !related || related !== elem ) {
sawine@5: 					elems.push({ elem: elem, handleObj: handleObj, level: close.level });
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	for ( i = 0, l = elems.length; i < l; i++ ) {
sawine@5: 		match = elems[i];
sawine@5: 
sawine@5: 		if ( maxLevel && match.level > maxLevel ) {
sawine@5: 			break;
sawine@5: 		}
sawine@5: 
sawine@5: 		event.currentTarget = match.elem;
sawine@5: 		event.data = match.handleObj.data;
sawine@5: 		event.handleObj = match.handleObj;
sawine@5: 
sawine@5: 		ret = match.handleObj.origHandler.apply( match.elem, arguments );
sawine@5: 
sawine@5: 		if ( ret === false || event.isPropagationStopped() ) {
sawine@5: 			maxLevel = match.level;
sawine@5: 
sawine@5: 			if ( ret === false ) {
sawine@5: 				stop = false;
sawine@5: 			}
sawine@5: 			if ( event.isImmediatePropagationStopped() ) {
sawine@5: 				break;
sawine@5: 			}
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	return stop;
sawine@5: }
sawine@5: 
sawine@5: function liveConvert( type, selector ) {
sawine@5: 	return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&");
sawine@5: }
sawine@5: 
sawine@5: jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
sawine@5: 	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
sawine@5: 	"change select submit keydown keypress keyup error").split(" "), function( i, name ) {
sawine@5: 
sawine@5: 	// Handle event binding
sawine@5: 	jQuery.fn[ name ] = function( data, fn ) {
sawine@5: 		if ( fn == null ) {
sawine@5: 			fn = data;
sawine@5: 			data = null;
sawine@5: 		}
sawine@5: 
sawine@5: 		return arguments.length > 0 ?
sawine@5: 			this.bind( name, data, fn ) :
sawine@5: 			this.trigger( name );
sawine@5: 	};
sawine@5: 
sawine@5: 	if ( jQuery.attrFn ) {
sawine@5: 		jQuery.attrFn[ name ] = true;
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: /*!
sawine@5:  * Sizzle CSS Selector Engine
sawine@5:  *  Copyright 2011, The Dojo Foundation
sawine@5:  *  Released under the MIT, BSD, and GPL Licenses.
sawine@5:  *  More information: http://sizzlejs.com/
sawine@5:  */
sawine@5: (function(){
sawine@5: 
sawine@5: var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
sawine@5: 	done = 0,
sawine@5: 	toString = Object.prototype.toString,
sawine@5: 	hasDuplicate = false,
sawine@5: 	baseHasDuplicate = true,
sawine@5: 	rBackslash = /\\/g,
sawine@5: 	rNonWord = /\W/;
sawine@5: 
sawine@5: // Here we check if the JavaScript engine is using some sort of
sawine@5: // optimization where it does not always call our comparision
sawine@5: // function. If that is the case, discard the hasDuplicate value.
sawine@5: //   Thus far that includes Google Chrome.
sawine@5: [0, 0].sort(function() {
sawine@5: 	baseHasDuplicate = false;
sawine@5: 	return 0;
sawine@5: });
sawine@5: 
sawine@5: var Sizzle = function( selector, context, results, seed ) {
sawine@5: 	results = results || [];
sawine@5: 	context = context || document;
sawine@5: 
sawine@5: 	var origContext = context;
sawine@5: 
sawine@5: 	if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
sawine@5: 		return [];
sawine@5: 	}
sawine@5: 	
sawine@5: 	if ( !selector || typeof selector !== "string" ) {
sawine@5: 		return results;
sawine@5: 	}
sawine@5: 
sawine@5: 	var m, set, checkSet, extra, ret, cur, pop, i,
sawine@5: 		prune = true,
sawine@5: 		contextXML = Sizzle.isXML( context ),
sawine@5: 		parts = [],
sawine@5: 		soFar = selector;
sawine@5: 	
sawine@5: 	// Reset the position of the chunker regexp (start from head)
sawine@5: 	do {
sawine@5: 		chunker.exec( "" );
sawine@5: 		m = chunker.exec( soFar );
sawine@5: 
sawine@5: 		if ( m ) {
sawine@5: 			soFar = m[3];
sawine@5: 		
sawine@5: 			parts.push( m[1] );
sawine@5: 		
sawine@5: 			if ( m[2] ) {
sawine@5: 				extra = m[3];
sawine@5: 				break;
sawine@5: 			}
sawine@5: 		}
sawine@5: 	} while ( m );
sawine@5: 
sawine@5: 	if ( parts.length > 1 && origPOS.exec( selector ) ) {
sawine@5: 
sawine@5: 		if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
sawine@5: 			set = posProcess( parts[0] + parts[1], context );
sawine@5: 
sawine@5: 		} else {
sawine@5: 			set = Expr.relative[ parts[0] ] ?
sawine@5: 				[ context ] :
sawine@5: 				Sizzle( parts.shift(), context );
sawine@5: 
sawine@5: 			while ( parts.length ) {
sawine@5: 				selector = parts.shift();
sawine@5: 
sawine@5: 				if ( Expr.relative[ selector ] ) {
sawine@5: 					selector += parts.shift();
sawine@5: 				}
sawine@5: 				
sawine@5: 				set = posProcess( selector, set );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 	} else {
sawine@5: 		// Take a shortcut and set the context if the root selector is an ID
sawine@5: 		// (but not if it'll be faster if the inner selector is an ID)
sawine@5: 		if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
sawine@5: 				Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
sawine@5: 
sawine@5: 			ret = Sizzle.find( parts.shift(), context, contextXML );
sawine@5: 			context = ret.expr ?
sawine@5: 				Sizzle.filter( ret.expr, ret.set )[0] :
sawine@5: 				ret.set[0];
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( context ) {
sawine@5: 			ret = seed ?
sawine@5: 				{ expr: parts.pop(), set: makeArray(seed) } :
sawine@5: 				Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
sawine@5: 
sawine@5: 			set = ret.expr ?
sawine@5: 				Sizzle.filter( ret.expr, ret.set ) :
sawine@5: 				ret.set;
sawine@5: 
sawine@5: 			if ( parts.length > 0 ) {
sawine@5: 				checkSet = makeArray( set );
sawine@5: 
sawine@5: 			} else {
sawine@5: 				prune = false;
sawine@5: 			}
sawine@5: 
sawine@5: 			while ( parts.length ) {
sawine@5: 				cur = parts.pop();
sawine@5: 				pop = cur;
sawine@5: 
sawine@5: 				if ( !Expr.relative[ cur ] ) {
sawine@5: 					cur = "";
sawine@5: 				} else {
sawine@5: 					pop = parts.pop();
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( pop == null ) {
sawine@5: 					pop = context;
sawine@5: 				}
sawine@5: 
sawine@5: 				Expr.relative[ cur ]( checkSet, pop, contextXML );
sawine@5: 			}
sawine@5: 
sawine@5: 		} else {
sawine@5: 			checkSet = parts = [];
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	if ( !checkSet ) {
sawine@5: 		checkSet = set;
sawine@5: 	}
sawine@5: 
sawine@5: 	if ( !checkSet ) {
sawine@5: 		Sizzle.error( cur || selector );
sawine@5: 	}
sawine@5: 
sawine@5: 	if ( toString.call(checkSet) === "[object Array]" ) {
sawine@5: 		if ( !prune ) {
sawine@5: 			results.push.apply( results, checkSet );
sawine@5: 
sawine@5: 		} else if ( context && context.nodeType === 1 ) {
sawine@5: 			for ( i = 0; checkSet[i] != null; i++ ) {
sawine@5: 				if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
sawine@5: 					results.push( set[i] );
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 		} else {
sawine@5: 			for ( i = 0; checkSet[i] != null; i++ ) {
sawine@5: 				if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
sawine@5: 					results.push( set[i] );
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 	} else {
sawine@5: 		makeArray( checkSet, results );
sawine@5: 	}
sawine@5: 
sawine@5: 	if ( extra ) {
sawine@5: 		Sizzle( extra, origContext, results, seed );
sawine@5: 		Sizzle.uniqueSort( results );
sawine@5: 	}
sawine@5: 
sawine@5: 	return results;
sawine@5: };
sawine@5: 
sawine@5: Sizzle.uniqueSort = function( results ) {
sawine@5: 	if ( sortOrder ) {
sawine@5: 		hasDuplicate = baseHasDuplicate;
sawine@5: 		results.sort( sortOrder );
sawine@5: 
sawine@5: 		if ( hasDuplicate ) {
sawine@5: 			for ( var i = 1; i < results.length; i++ ) {
sawine@5: 				if ( results[i] === results[ i - 1 ] ) {
sawine@5: 					results.splice( i--, 1 );
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	return results;
sawine@5: };
sawine@5: 
sawine@5: Sizzle.matches = function( expr, set ) {
sawine@5: 	return Sizzle( expr, null, null, set );
sawine@5: };
sawine@5: 
sawine@5: Sizzle.matchesSelector = function( node, expr ) {
sawine@5: 	return Sizzle( expr, null, null, [node] ).length > 0;
sawine@5: };
sawine@5: 
sawine@5: Sizzle.find = function( expr, context, isXML ) {
sawine@5: 	var set;
sawine@5: 
sawine@5: 	if ( !expr ) {
sawine@5: 		return [];
sawine@5: 	}
sawine@5: 
sawine@5: 	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
sawine@5: 		var match,
sawine@5: 			type = Expr.order[i];
sawine@5: 		
sawine@5: 		if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
sawine@5: 			var left = match[1];
sawine@5: 			match.splice( 1, 1 );
sawine@5: 
sawine@5: 			if ( left.substr( left.length - 1 ) !== "\\" ) {
sawine@5: 				match[1] = (match[1] || "").replace( rBackslash, "" );
sawine@5: 				set = Expr.find[ type ]( match, context, isXML );
sawine@5: 
sawine@5: 				if ( set != null ) {
sawine@5: 					expr = expr.replace( Expr.match[ type ], "" );
sawine@5: 					break;
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	if ( !set ) {
sawine@5: 		set = typeof context.getElementsByTagName !== "undefined" ?
sawine@5: 			context.getElementsByTagName( "*" ) :
sawine@5: 			[];
sawine@5: 	}
sawine@5: 
sawine@5: 	return { set: set, expr: expr };
sawine@5: };
sawine@5: 
sawine@5: Sizzle.filter = function( expr, set, inplace, not ) {
sawine@5: 	var match, anyFound,
sawine@5: 		old = expr,
sawine@5: 		result = [],
sawine@5: 		curLoop = set,
sawine@5: 		isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
sawine@5: 
sawine@5: 	while ( expr && set.length ) {
sawine@5: 		for ( var type in Expr.filter ) {
sawine@5: 			if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
sawine@5: 				var found, item,
sawine@5: 					filter = Expr.filter[ type ],
sawine@5: 					left = match[1];
sawine@5: 
sawine@5: 				anyFound = false;
sawine@5: 
sawine@5: 				match.splice(1,1);
sawine@5: 
sawine@5: 				if ( left.substr( left.length - 1 ) === "\\" ) {
sawine@5: 					continue;
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( curLoop === result ) {
sawine@5: 					result = [];
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( Expr.preFilter[ type ] ) {
sawine@5: 					match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
sawine@5: 
sawine@5: 					if ( !match ) {
sawine@5: 						anyFound = found = true;
sawine@5: 
sawine@5: 					} else if ( match === true ) {
sawine@5: 						continue;
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( match ) {
sawine@5: 					for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
sawine@5: 						if ( item ) {
sawine@5: 							found = filter( item, match, i, curLoop );
sawine@5: 							var pass = not ^ !!found;
sawine@5: 
sawine@5: 							if ( inplace && found != null ) {
sawine@5: 								if ( pass ) {
sawine@5: 									anyFound = true;
sawine@5: 
sawine@5: 								} else {
sawine@5: 									curLoop[i] = false;
sawine@5: 								}
sawine@5: 
sawine@5: 							} else if ( pass ) {
sawine@5: 								result.push( item );
sawine@5: 								anyFound = true;
sawine@5: 							}
sawine@5: 						}
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( found !== undefined ) {
sawine@5: 					if ( !inplace ) {
sawine@5: 						curLoop = result;
sawine@5: 					}
sawine@5: 
sawine@5: 					expr = expr.replace( Expr.match[ type ], "" );
sawine@5: 
sawine@5: 					if ( !anyFound ) {
sawine@5: 						return [];
sawine@5: 					}
sawine@5: 
sawine@5: 					break;
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		// Improper expression
sawine@5: 		if ( expr === old ) {
sawine@5: 			if ( anyFound == null ) {
sawine@5: 				Sizzle.error( expr );
sawine@5: 
sawine@5: 			} else {
sawine@5: 				break;
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		old = expr;
sawine@5: 	}
sawine@5: 
sawine@5: 	return curLoop;
sawine@5: };
sawine@5: 
sawine@5: Sizzle.error = function( msg ) {
sawine@5: 	throw "Syntax error, unrecognized expression: " + msg;
sawine@5: };
sawine@5: 
sawine@5: var Expr = Sizzle.selectors = {
sawine@5: 	order: [ "ID", "NAME", "TAG" ],
sawine@5: 
sawine@5: 	match: {
sawine@5: 		ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
sawine@5: 		CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
sawine@5: 		NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
sawine@5: 		ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
sawine@5: 		TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
sawine@5: 		CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
sawine@5: 		POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
sawine@5: 		PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
sawine@5: 	},
sawine@5: 
sawine@5: 	leftMatch: {},
sawine@5: 
sawine@5: 	attrMap: {
sawine@5: 		"class": "className",
sawine@5: 		"for": "htmlFor"
sawine@5: 	},
sawine@5: 
sawine@5: 	attrHandle: {
sawine@5: 		href: function( elem ) {
sawine@5: 			return elem.getAttribute( "href" );
sawine@5: 		},
sawine@5: 		type: function( elem ) {
sawine@5: 			return elem.getAttribute( "type" );
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	relative: {
sawine@5: 		"+": function(checkSet, part){
sawine@5: 			var isPartStr = typeof part === "string",
sawine@5: 				isTag = isPartStr && !rNonWord.test( part ),
sawine@5: 				isPartStrNotTag = isPartStr && !isTag;
sawine@5: 
sawine@5: 			if ( isTag ) {
sawine@5: 				part = part.toLowerCase();
sawine@5: 			}
sawine@5: 
sawine@5: 			for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
sawine@5: 				if ( (elem = checkSet[i]) ) {
sawine@5: 					while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
sawine@5: 
sawine@5: 					checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
sawine@5: 						elem || false :
sawine@5: 						elem === part;
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( isPartStrNotTag ) {
sawine@5: 				Sizzle.filter( part, checkSet, true );
sawine@5: 			}
sawine@5: 		},
sawine@5: 
sawine@5: 		">": function( checkSet, part ) {
sawine@5: 			var elem,
sawine@5: 				isPartStr = typeof part === "string",
sawine@5: 				i = 0,
sawine@5: 				l = checkSet.length;
sawine@5: 
sawine@5: 			if ( isPartStr && !rNonWord.test( part ) ) {
sawine@5: 				part = part.toLowerCase();
sawine@5: 
sawine@5: 				for ( ; i < l; i++ ) {
sawine@5: 					elem = checkSet[i];
sawine@5: 
sawine@5: 					if ( elem ) {
sawine@5: 						var parent = elem.parentNode;
sawine@5: 						checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 			} else {
sawine@5: 				for ( ; i < l; i++ ) {
sawine@5: 					elem = checkSet[i];
sawine@5: 
sawine@5: 					if ( elem ) {
sawine@5: 						checkSet[i] = isPartStr ?
sawine@5: 							elem.parentNode :
sawine@5: 							elem.parentNode === part;
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( isPartStr ) {
sawine@5: 					Sizzle.filter( part, checkSet, true );
sawine@5: 				}
sawine@5: 			}
sawine@5: 		},
sawine@5: 
sawine@5: 		"": function(checkSet, part, isXML){
sawine@5: 			var nodeCheck,
sawine@5: 				doneName = done++,
sawine@5: 				checkFn = dirCheck;
sawine@5: 
sawine@5: 			if ( typeof part === "string" && !rNonWord.test( part ) ) {
sawine@5: 				part = part.toLowerCase();
sawine@5: 				nodeCheck = part;
sawine@5: 				checkFn = dirNodeCheck;
sawine@5: 			}
sawine@5: 
sawine@5: 			checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
sawine@5: 		},
sawine@5: 
sawine@5: 		"~": function( checkSet, part, isXML ) {
sawine@5: 			var nodeCheck,
sawine@5: 				doneName = done++,
sawine@5: 				checkFn = dirCheck;
sawine@5: 
sawine@5: 			if ( typeof part === "string" && !rNonWord.test( part ) ) {
sawine@5: 				part = part.toLowerCase();
sawine@5: 				nodeCheck = part;
sawine@5: 				checkFn = dirNodeCheck;
sawine@5: 			}
sawine@5: 
sawine@5: 			checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	find: {
sawine@5: 		ID: function( match, context, isXML ) {
sawine@5: 			if ( typeof context.getElementById !== "undefined" && !isXML ) {
sawine@5: 				var m = context.getElementById(match[1]);
sawine@5: 				// Check parentNode to catch when Blackberry 4.6 returns
sawine@5: 				// nodes that are no longer in the document #6963
sawine@5: 				return m && m.parentNode ? [m] : [];
sawine@5: 			}
sawine@5: 		},
sawine@5: 
sawine@5: 		NAME: function( match, context ) {
sawine@5: 			if ( typeof context.getElementsByName !== "undefined" ) {
sawine@5: 				var ret = [],
sawine@5: 					results = context.getElementsByName( match[1] );
sawine@5: 
sawine@5: 				for ( var i = 0, l = results.length; i < l; i++ ) {
sawine@5: 					if ( results[i].getAttribute("name") === match[1] ) {
sawine@5: 						ret.push( results[i] );
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				return ret.length === 0 ? null : ret;
sawine@5: 			}
sawine@5: 		},
sawine@5: 
sawine@5: 		TAG: function( match, context ) {
sawine@5: 			if ( typeof context.getElementsByTagName !== "undefined" ) {
sawine@5: 				return context.getElementsByTagName( match[1] );
sawine@5: 			}
sawine@5: 		}
sawine@5: 	},
sawine@5: 	preFilter: {
sawine@5: 		CLASS: function( match, curLoop, inplace, result, not, isXML ) {
sawine@5: 			match = " " + match[1].replace( rBackslash, "" ) + " ";
sawine@5: 
sawine@5: 			if ( isXML ) {
sawine@5: 				return match;
sawine@5: 			}
sawine@5: 
sawine@5: 			for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
sawine@5: 				if ( elem ) {
sawine@5: 					if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
sawine@5: 						if ( !inplace ) {
sawine@5: 							result.push( elem );
sawine@5: 						}
sawine@5: 
sawine@5: 					} else if ( inplace ) {
sawine@5: 						curLoop[i] = false;
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			return false;
sawine@5: 		},
sawine@5: 
sawine@5: 		ID: function( match ) {
sawine@5: 			return match[1].replace( rBackslash, "" );
sawine@5: 		},
sawine@5: 
sawine@5: 		TAG: function( match, curLoop ) {
sawine@5: 			return match[1].replace( rBackslash, "" ).toLowerCase();
sawine@5: 		},
sawine@5: 
sawine@5: 		CHILD: function( match ) {
sawine@5: 			if ( match[1] === "nth" ) {
sawine@5: 				if ( !match[2] ) {
sawine@5: 					Sizzle.error( match[0] );
sawine@5: 				}
sawine@5: 
sawine@5: 				match[2] = match[2].replace(/^\+|\s*/g, '');
sawine@5: 
sawine@5: 				// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
sawine@5: 				var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
sawine@5: 					match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
sawine@5: 					!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
sawine@5: 
sawine@5: 				// calculate the numbers (first)n+(last) including if they are negative
sawine@5: 				match[2] = (test[1] + (test[2] || 1)) - 0;
sawine@5: 				match[3] = test[3] - 0;
sawine@5: 			}
sawine@5: 			else if ( match[2] ) {
sawine@5: 				Sizzle.error( match[0] );
sawine@5: 			}
sawine@5: 
sawine@5: 			// TODO: Move to normal caching system
sawine@5: 			match[0] = done++;
sawine@5: 
sawine@5: 			return match;
sawine@5: 		},
sawine@5: 
sawine@5: 		ATTR: function( match, curLoop, inplace, result, not, isXML ) {
sawine@5: 			var name = match[1] = match[1].replace( rBackslash, "" );
sawine@5: 			
sawine@5: 			if ( !isXML && Expr.attrMap[name] ) {
sawine@5: 				match[1] = Expr.attrMap[name];
sawine@5: 			}
sawine@5: 
sawine@5: 			// Handle if an un-quoted value was used
sawine@5: 			match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );
sawine@5: 
sawine@5: 			if ( match[2] === "~=" ) {
sawine@5: 				match[4] = " " + match[4] + " ";
sawine@5: 			}
sawine@5: 
sawine@5: 			return match;
sawine@5: 		},
sawine@5: 
sawine@5: 		PSEUDO: function( match, curLoop, inplace, result, not ) {
sawine@5: 			if ( match[1] === "not" ) {
sawine@5: 				// If we're dealing with a complex expression, or a simple one
sawine@5: 				if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
sawine@5: 					match[3] = Sizzle(match[3], null, null, curLoop);
sawine@5: 
sawine@5: 				} else {
sawine@5: 					var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
sawine@5: 
sawine@5: 					if ( !inplace ) {
sawine@5: 						result.push.apply( result, ret );
sawine@5: 					}
sawine@5: 
sawine@5: 					return false;
sawine@5: 				}
sawine@5: 
sawine@5: 			} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
sawine@5: 				return true;
sawine@5: 			}
sawine@5: 			
sawine@5: 			return match;
sawine@5: 		},
sawine@5: 
sawine@5: 		POS: function( match ) {
sawine@5: 			match.unshift( true );
sawine@5: 
sawine@5: 			return match;
sawine@5: 		}
sawine@5: 	},
sawine@5: 	
sawine@5: 	filters: {
sawine@5: 		enabled: function( elem ) {
sawine@5: 			return elem.disabled === false && elem.type !== "hidden";
sawine@5: 		},
sawine@5: 
sawine@5: 		disabled: function( elem ) {
sawine@5: 			return elem.disabled === true;
sawine@5: 		},
sawine@5: 
sawine@5: 		checked: function( elem ) {
sawine@5: 			return elem.checked === true;
sawine@5: 		},
sawine@5: 		
sawine@5: 		selected: function( elem ) {
sawine@5: 			// Accessing this property makes selected-by-default
sawine@5: 			// options in Safari work properly
sawine@5: 			if ( elem.parentNode ) {
sawine@5: 				elem.parentNode.selectedIndex;
sawine@5: 			}
sawine@5: 			
sawine@5: 			return elem.selected === true;
sawine@5: 		},
sawine@5: 
sawine@5: 		parent: function( elem ) {
sawine@5: 			return !!elem.firstChild;
sawine@5: 		},
sawine@5: 
sawine@5: 		empty: function( elem ) {
sawine@5: 			return !elem.firstChild;
sawine@5: 		},
sawine@5: 
sawine@5: 		has: function( elem, i, match ) {
sawine@5: 			return !!Sizzle( match[3], elem ).length;
sawine@5: 		},
sawine@5: 
sawine@5: 		header: function( elem ) {
sawine@5: 			return (/h\d/i).test( elem.nodeName );
sawine@5: 		},
sawine@5: 
sawine@5: 		text: function( elem ) {
sawine@5: 			var attr = elem.getAttribute( "type" ), type = elem.type;
sawine@5: 			// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc) 
sawine@5: 			// use getAttribute instead to test this case
sawine@5: 			return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );
sawine@5: 		},
sawine@5: 
sawine@5: 		radio: function( elem ) {
sawine@5: 			return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
sawine@5: 		},
sawine@5: 
sawine@5: 		checkbox: function( elem ) {
sawine@5: 			return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
sawine@5: 		},
sawine@5: 
sawine@5: 		file: function( elem ) {
sawine@5: 			return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
sawine@5: 		},
sawine@5: 
sawine@5: 		password: function( elem ) {
sawine@5: 			return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
sawine@5: 		},
sawine@5: 
sawine@5: 		submit: function( elem ) {
sawine@5: 			var name = elem.nodeName.toLowerCase();
sawine@5: 			return (name === "input" || name === "button") && "submit" === elem.type;
sawine@5: 		},
sawine@5: 
sawine@5: 		image: function( elem ) {
sawine@5: 			return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
sawine@5: 		},
sawine@5: 
sawine@5: 		reset: function( elem ) {
sawine@5: 			var name = elem.nodeName.toLowerCase();
sawine@5: 			return (name === "input" || name === "button") && "reset" === elem.type;
sawine@5: 		},
sawine@5: 
sawine@5: 		button: function( elem ) {
sawine@5: 			var name = elem.nodeName.toLowerCase();
sawine@5: 			return name === "input" && "button" === elem.type || name === "button";
sawine@5: 		},
sawine@5: 
sawine@5: 		input: function( elem ) {
sawine@5: 			return (/input|select|textarea|button/i).test( elem.nodeName );
sawine@5: 		},
sawine@5: 
sawine@5: 		focus: function( elem ) {
sawine@5: 			return elem === elem.ownerDocument.activeElement;
sawine@5: 		}
sawine@5: 	},
sawine@5: 	setFilters: {
sawine@5: 		first: function( elem, i ) {
sawine@5: 			return i === 0;
sawine@5: 		},
sawine@5: 
sawine@5: 		last: function( elem, i, match, array ) {
sawine@5: 			return i === array.length - 1;
sawine@5: 		},
sawine@5: 
sawine@5: 		even: function( elem, i ) {
sawine@5: 			return i % 2 === 0;
sawine@5: 		},
sawine@5: 
sawine@5: 		odd: function( elem, i ) {
sawine@5: 			return i % 2 === 1;
sawine@5: 		},
sawine@5: 
sawine@5: 		lt: function( elem, i, match ) {
sawine@5: 			return i < match[3] - 0;
sawine@5: 		},
sawine@5: 
sawine@5: 		gt: function( elem, i, match ) {
sawine@5: 			return i > match[3] - 0;
sawine@5: 		},
sawine@5: 
sawine@5: 		nth: function( elem, i, match ) {
sawine@5: 			return match[3] - 0 === i;
sawine@5: 		},
sawine@5: 
sawine@5: 		eq: function( elem, i, match ) {
sawine@5: 			return match[3] - 0 === i;
sawine@5: 		}
sawine@5: 	},
sawine@5: 	filter: {
sawine@5: 		PSEUDO: function( elem, match, i, array ) {
sawine@5: 			var name = match[1],
sawine@5: 				filter = Expr.filters[ name ];
sawine@5: 
sawine@5: 			if ( filter ) {
sawine@5: 				return filter( elem, i, match, array );
sawine@5: 
sawine@5: 			} else if ( name === "contains" ) {
sawine@5: 				return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
sawine@5: 
sawine@5: 			} else if ( name === "not" ) {
sawine@5: 				var not = match[3];
sawine@5: 
sawine@5: 				for ( var j = 0, l = not.length; j < l; j++ ) {
sawine@5: 					if ( not[j] === elem ) {
sawine@5: 						return false;
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				return true;
sawine@5: 
sawine@5: 			} else {
sawine@5: 				Sizzle.error( name );
sawine@5: 			}
sawine@5: 		},
sawine@5: 
sawine@5: 		CHILD: function( elem, match ) {
sawine@5: 			var type = match[1],
sawine@5: 				node = elem;
sawine@5: 
sawine@5: 			switch ( type ) {
sawine@5: 				case "only":
sawine@5: 				case "first":
sawine@5: 					while ( (node = node.previousSibling) )	 {
sawine@5: 						if ( node.nodeType === 1 ) { 
sawine@5: 							return false; 
sawine@5: 						}
sawine@5: 					}
sawine@5: 
sawine@5: 					if ( type === "first" ) { 
sawine@5: 						return true; 
sawine@5: 					}
sawine@5: 
sawine@5: 					node = elem;
sawine@5: 
sawine@5: 				case "last":
sawine@5: 					while ( (node = node.nextSibling) )	 {
sawine@5: 						if ( node.nodeType === 1 ) { 
sawine@5: 							return false; 
sawine@5: 						}
sawine@5: 					}
sawine@5: 
sawine@5: 					return true;
sawine@5: 
sawine@5: 				case "nth":
sawine@5: 					var first = match[2],
sawine@5: 						last = match[3];
sawine@5: 
sawine@5: 					if ( first === 1 && last === 0 ) {
sawine@5: 						return true;
sawine@5: 					}
sawine@5: 					
sawine@5: 					var doneName = match[0],
sawine@5: 						parent = elem.parentNode;
sawine@5: 	
sawine@5: 					if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
sawine@5: 						var count = 0;
sawine@5: 						
sawine@5: 						for ( node = parent.firstChild; node; node = node.nextSibling ) {
sawine@5: 							if ( node.nodeType === 1 ) {
sawine@5: 								node.nodeIndex = ++count;
sawine@5: 							}
sawine@5: 						} 
sawine@5: 
sawine@5: 						parent.sizcache = doneName;
sawine@5: 					}
sawine@5: 					
sawine@5: 					var diff = elem.nodeIndex - last;
sawine@5: 
sawine@5: 					if ( first === 0 ) {
sawine@5: 						return diff === 0;
sawine@5: 
sawine@5: 					} else {
sawine@5: 						return ( diff % first === 0 && diff / first >= 0 );
sawine@5: 					}
sawine@5: 			}
sawine@5: 		},
sawine@5: 
sawine@5: 		ID: function( elem, match ) {
sawine@5: 			return elem.nodeType === 1 && elem.getAttribute("id") === match;
sawine@5: 		},
sawine@5: 
sawine@5: 		TAG: function( elem, match ) {
sawine@5: 			return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
sawine@5: 		},
sawine@5: 		
sawine@5: 		CLASS: function( elem, match ) {
sawine@5: 			return (" " + (elem.className || elem.getAttribute("class")) + " ")
sawine@5: 				.indexOf( match ) > -1;
sawine@5: 		},
sawine@5: 
sawine@5: 		ATTR: function( elem, match ) {
sawine@5: 			var name = match[1],
sawine@5: 				result = Expr.attrHandle[ name ] ?
sawine@5: 					Expr.attrHandle[ name ]( elem ) :
sawine@5: 					elem[ name ] != null ?
sawine@5: 						elem[ name ] :
sawine@5: 						elem.getAttribute( name ),
sawine@5: 				value = result + "",
sawine@5: 				type = match[2],
sawine@5: 				check = match[4];
sawine@5: 
sawine@5: 			return result == null ?
sawine@5: 				type === "!=" :
sawine@5: 				type === "=" ?
sawine@5: 				value === check :
sawine@5: 				type === "*=" ?
sawine@5: 				value.indexOf(check) >= 0 :
sawine@5: 				type === "~=" ?
sawine@5: 				(" " + value + " ").indexOf(check) >= 0 :
sawine@5: 				!check ?
sawine@5: 				value && result !== false :
sawine@5: 				type === "!=" ?
sawine@5: 				value !== check :
sawine@5: 				type === "^=" ?
sawine@5: 				value.indexOf(check) === 0 :
sawine@5: 				type === "$=" ?
sawine@5: 				value.substr(value.length - check.length) === check :
sawine@5: 				type === "|=" ?
sawine@5: 				value === check || value.substr(0, check.length + 1) === check + "-" :
sawine@5: 				false;
sawine@5: 		},
sawine@5: 
sawine@5: 		POS: function( elem, match, i, array ) {
sawine@5: 			var name = match[2],
sawine@5: 				filter = Expr.setFilters[ name ];
sawine@5: 
sawine@5: 			if ( filter ) {
sawine@5: 				return filter( elem, i, match, array );
sawine@5: 			}
sawine@5: 		}
sawine@5: 	}
sawine@5: };
sawine@5: 
sawine@5: var origPOS = Expr.match.POS,
sawine@5: 	fescape = function(all, num){
sawine@5: 		return "\\" + (num - 0 + 1);
sawine@5: 	};
sawine@5: 
sawine@5: for ( var type in Expr.match ) {
sawine@5: 	Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
sawine@5: 	Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
sawine@5: }
sawine@5: 
sawine@5: var makeArray = function( array, results ) {
sawine@5: 	array = Array.prototype.slice.call( array, 0 );
sawine@5: 
sawine@5: 	if ( results ) {
sawine@5: 		results.push.apply( results, array );
sawine@5: 		return results;
sawine@5: 	}
sawine@5: 	
sawine@5: 	return array;
sawine@5: };
sawine@5: 
sawine@5: // Perform a simple check to determine if the browser is capable of
sawine@5: // converting a NodeList to an array using builtin methods.
sawine@5: // Also verifies that the returned array holds DOM nodes
sawine@5: // (which is not the case in the Blackberry browser)
sawine@5: try {
sawine@5: 	Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
sawine@5: 
sawine@5: // Provide a fallback method if it does not work
sawine@5: } catch( e ) {
sawine@5: 	makeArray = function( array, results ) {
sawine@5: 		var i = 0,
sawine@5: 			ret = results || [];
sawine@5: 
sawine@5: 		if ( toString.call(array) === "[object Array]" ) {
sawine@5: 			Array.prototype.push.apply( ret, array );
sawine@5: 
sawine@5: 		} else {
sawine@5: 			if ( typeof array.length === "number" ) {
sawine@5: 				for ( var l = array.length; i < l; i++ ) {
sawine@5: 					ret.push( array[i] );
sawine@5: 				}
sawine@5: 
sawine@5: 			} else {
sawine@5: 				for ( ; array[i]; i++ ) {
sawine@5: 					ret.push( array[i] );
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return ret;
sawine@5: 	};
sawine@5: }
sawine@5: 
sawine@5: var sortOrder, siblingCheck;
sawine@5: 
sawine@5: if ( document.documentElement.compareDocumentPosition ) {
sawine@5: 	sortOrder = function( a, b ) {
sawine@5: 		if ( a === b ) {
sawine@5: 			hasDuplicate = true;
sawine@5: 			return 0;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
sawine@5: 			return a.compareDocumentPosition ? -1 : 1;
sawine@5: 		}
sawine@5: 
sawine@5: 		return a.compareDocumentPosition(b) & 4 ? -1 : 1;
sawine@5: 	};
sawine@5: 
sawine@5: } else {
sawine@5: 	sortOrder = function( a, b ) {
sawine@5: 		// The nodes are identical, we can exit early
sawine@5: 		if ( a === b ) {
sawine@5: 			hasDuplicate = true;
sawine@5: 			return 0;
sawine@5: 
sawine@5: 		// Fallback to using sourceIndex (in IE) if it's available on both nodes
sawine@5: 		} else if ( a.sourceIndex && b.sourceIndex ) {
sawine@5: 			return a.sourceIndex - b.sourceIndex;
sawine@5: 		}
sawine@5: 
sawine@5: 		var al, bl,
sawine@5: 			ap = [],
sawine@5: 			bp = [],
sawine@5: 			aup = a.parentNode,
sawine@5: 			bup = b.parentNode,
sawine@5: 			cur = aup;
sawine@5: 
sawine@5: 		// If the nodes are siblings (or identical) we can do a quick check
sawine@5: 		if ( aup === bup ) {
sawine@5: 			return siblingCheck( a, b );
sawine@5: 
sawine@5: 		// If no parents were found then the nodes are disconnected
sawine@5: 		} else if ( !aup ) {
sawine@5: 			return -1;
sawine@5: 
sawine@5: 		} else if ( !bup ) {
sawine@5: 			return 1;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Otherwise they're somewhere else in the tree so we need
sawine@5: 		// to build up a full list of the parentNodes for comparison
sawine@5: 		while ( cur ) {
sawine@5: 			ap.unshift( cur );
sawine@5: 			cur = cur.parentNode;
sawine@5: 		}
sawine@5: 
sawine@5: 		cur = bup;
sawine@5: 
sawine@5: 		while ( cur ) {
sawine@5: 			bp.unshift( cur );
sawine@5: 			cur = cur.parentNode;
sawine@5: 		}
sawine@5: 
sawine@5: 		al = ap.length;
sawine@5: 		bl = bp.length;
sawine@5: 
sawine@5: 		// Start walking down the tree looking for a discrepancy
sawine@5: 		for ( var i = 0; i < al && i < bl; i++ ) {
sawine@5: 			if ( ap[i] !== bp[i] ) {
sawine@5: 				return siblingCheck( ap[i], bp[i] );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		// We ended someplace up the tree so do a sibling check
sawine@5: 		return i === al ?
sawine@5: 			siblingCheck( a, bp[i], -1 ) :
sawine@5: 			siblingCheck( ap[i], b, 1 );
sawine@5: 	};
sawine@5: 
sawine@5: 	siblingCheck = function( a, b, ret ) {
sawine@5: 		if ( a === b ) {
sawine@5: 			return ret;
sawine@5: 		}
sawine@5: 
sawine@5: 		var cur = a.nextSibling;
sawine@5: 
sawine@5: 		while ( cur ) {
sawine@5: 			if ( cur === b ) {
sawine@5: 				return -1;
sawine@5: 			}
sawine@5: 
sawine@5: 			cur = cur.nextSibling;
sawine@5: 		}
sawine@5: 
sawine@5: 		return 1;
sawine@5: 	};
sawine@5: }
sawine@5: 
sawine@5: // Utility function for retreiving the text value of an array of DOM nodes
sawine@5: Sizzle.getText = function( elems ) {
sawine@5: 	var ret = "", elem;
sawine@5: 
sawine@5: 	for ( var i = 0; elems[i]; i++ ) {
sawine@5: 		elem = elems[i];
sawine@5: 
sawine@5: 		// Get the text from text nodes and CDATA nodes
sawine@5: 		if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
sawine@5: 			ret += elem.nodeValue;
sawine@5: 
sawine@5: 		// Traverse everything else, except comment nodes
sawine@5: 		} else if ( elem.nodeType !== 8 ) {
sawine@5: 			ret += Sizzle.getText( elem.childNodes );
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	return ret;
sawine@5: };
sawine@5: 
sawine@5: // Check to see if the browser returns elements by name when
sawine@5: // querying by getElementById (and provide a workaround)
sawine@5: (function(){
sawine@5: 	// We're going to inject a fake input element with a specified name
sawine@5: 	var form = document.createElement("div"),
sawine@5: 		id = "script" + (new Date()).getTime(),
sawine@5: 		root = document.documentElement;
sawine@5: 
sawine@5: 	form.innerHTML = "<a name='" + id + "'/>";
sawine@5: 
sawine@5: 	// Inject it into the root element, check its status, and remove it quickly
sawine@5: 	root.insertBefore( form, root.firstChild );
sawine@5: 
sawine@5: 	// The workaround has to do additional checks after a getElementById
sawine@5: 	// Which slows things down for other browsers (hence the branching)
sawine@5: 	if ( document.getElementById( id ) ) {
sawine@5: 		Expr.find.ID = function( match, context, isXML ) {
sawine@5: 			if ( typeof context.getElementById !== "undefined" && !isXML ) {
sawine@5: 				var m = context.getElementById(match[1]);
sawine@5: 
sawine@5: 				return m ?
sawine@5: 					m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
sawine@5: 						[m] :
sawine@5: 						undefined :
sawine@5: 					[];
sawine@5: 			}
sawine@5: 		};
sawine@5: 
sawine@5: 		Expr.filter.ID = function( elem, match ) {
sawine@5: 			var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
sawine@5: 
sawine@5: 			return elem.nodeType === 1 && node && node.nodeValue === match;
sawine@5: 		};
sawine@5: 	}
sawine@5: 
sawine@5: 	root.removeChild( form );
sawine@5: 
sawine@5: 	// release memory in IE
sawine@5: 	root = form = null;
sawine@5: })();
sawine@5: 
sawine@5: (function(){
sawine@5: 	// Check to see if the browser returns only elements
sawine@5: 	// when doing getElementsByTagName("*")
sawine@5: 
sawine@5: 	// Create a fake element
sawine@5: 	var div = document.createElement("div");
sawine@5: 	div.appendChild( document.createComment("") );
sawine@5: 
sawine@5: 	// Make sure no comments are found
sawine@5: 	if ( div.getElementsByTagName("*").length > 0 ) {
sawine@5: 		Expr.find.TAG = function( match, context ) {
sawine@5: 			var results = context.getElementsByTagName( match[1] );
sawine@5: 
sawine@5: 			// Filter out possible comments
sawine@5: 			if ( match[1] === "*" ) {
sawine@5: 				var tmp = [];
sawine@5: 
sawine@5: 				for ( var i = 0; results[i]; i++ ) {
sawine@5: 					if ( results[i].nodeType === 1 ) {
sawine@5: 						tmp.push( results[i] );
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				results = tmp;
sawine@5: 			}
sawine@5: 
sawine@5: 			return results;
sawine@5: 		};
sawine@5: 	}
sawine@5: 
sawine@5: 	// Check to see if an attribute returns normalized href attributes
sawine@5: 	div.innerHTML = "<a href='#'></a>";
sawine@5: 
sawine@5: 	if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
sawine@5: 			div.firstChild.getAttribute("href") !== "#" ) {
sawine@5: 
sawine@5: 		Expr.attrHandle.href = function( elem ) {
sawine@5: 			return elem.getAttribute( "href", 2 );
sawine@5: 		};
sawine@5: 	}
sawine@5: 
sawine@5: 	// release memory in IE
sawine@5: 	div = null;
sawine@5: })();
sawine@5: 
sawine@5: if ( document.querySelectorAll ) {
sawine@5: 	(function(){
sawine@5: 		var oldSizzle = Sizzle,
sawine@5: 			div = document.createElement("div"),
sawine@5: 			id = "__sizzle__";
sawine@5: 
sawine@5: 		div.innerHTML = "<p class='TEST'></p>";
sawine@5: 
sawine@5: 		// Safari can't handle uppercase or unicode characters when
sawine@5: 		// in quirks mode.
sawine@5: 		if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 	
sawine@5: 		Sizzle = function( query, context, extra, seed ) {
sawine@5: 			context = context || document;
sawine@5: 
sawine@5: 			// Only use querySelectorAll on non-XML documents
sawine@5: 			// (ID selectors don't work in non-HTML documents)
sawine@5: 			if ( !seed && !Sizzle.isXML(context) ) {
sawine@5: 				// See if we find a selector to speed up
sawine@5: 				var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
sawine@5: 				
sawine@5: 				if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
sawine@5: 					// Speed-up: Sizzle("TAG")
sawine@5: 					if ( match[1] ) {
sawine@5: 						return makeArray( context.getElementsByTagName( query ), extra );
sawine@5: 					
sawine@5: 					// Speed-up: Sizzle(".CLASS")
sawine@5: 					} else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
sawine@5: 						return makeArray( context.getElementsByClassName( match[2] ), extra );
sawine@5: 					}
sawine@5: 				}
sawine@5: 				
sawine@5: 				if ( context.nodeType === 9 ) {
sawine@5: 					// Speed-up: Sizzle("body")
sawine@5: 					// The body element only exists once, optimize finding it
sawine@5: 					if ( query === "body" && context.body ) {
sawine@5: 						return makeArray( [ context.body ], extra );
sawine@5: 						
sawine@5: 					// Speed-up: Sizzle("#ID")
sawine@5: 					} else if ( match && match[3] ) {
sawine@5: 						var elem = context.getElementById( match[3] );
sawine@5: 
sawine@5: 						// Check parentNode to catch when Blackberry 4.6 returns
sawine@5: 						// nodes that are no longer in the document #6963
sawine@5: 						if ( elem && elem.parentNode ) {
sawine@5: 							// Handle the case where IE and Opera return items
sawine@5: 							// by name instead of ID
sawine@5: 							if ( elem.id === match[3] ) {
sawine@5: 								return makeArray( [ elem ], extra );
sawine@5: 							}
sawine@5: 							
sawine@5: 						} else {
sawine@5: 							return makeArray( [], extra );
sawine@5: 						}
sawine@5: 					}
sawine@5: 					
sawine@5: 					try {
sawine@5: 						return makeArray( context.querySelectorAll(query), extra );
sawine@5: 					} catch(qsaError) {}
sawine@5: 
sawine@5: 				// qSA works strangely on Element-rooted queries
sawine@5: 				// We can work around this by specifying an extra ID on the root
sawine@5: 				// and working up from there (Thanks to Andrew Dupont for the technique)
sawine@5: 				// IE 8 doesn't work on object elements
sawine@5: 				} else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
sawine@5: 					var oldContext = context,
sawine@5: 						old = context.getAttribute( "id" ),
sawine@5: 						nid = old || id,
sawine@5: 						hasParent = context.parentNode,
sawine@5: 						relativeHierarchySelector = /^\s*[+~]/.test( query );
sawine@5: 
sawine@5: 					if ( !old ) {
sawine@5: 						context.setAttribute( "id", nid );
sawine@5: 					} else {
sawine@5: 						nid = nid.replace( /'/g, "\\$&" );
sawine@5: 					}
sawine@5: 					if ( relativeHierarchySelector && hasParent ) {
sawine@5: 						context = context.parentNode;
sawine@5: 					}
sawine@5: 
sawine@5: 					try {
sawine@5: 						if ( !relativeHierarchySelector || hasParent ) {
sawine@5: 							return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
sawine@5: 						}
sawine@5: 
sawine@5: 					} catch(pseudoError) {
sawine@5: 					} finally {
sawine@5: 						if ( !old ) {
sawine@5: 							oldContext.removeAttribute( "id" );
sawine@5: 						}
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 		
sawine@5: 			return oldSizzle(query, context, extra, seed);
sawine@5: 		};
sawine@5: 
sawine@5: 		for ( var prop in oldSizzle ) {
sawine@5: 			Sizzle[ prop ] = oldSizzle[ prop ];
sawine@5: 		}
sawine@5: 
sawine@5: 		// release memory in IE
sawine@5: 		div = null;
sawine@5: 	})();
sawine@5: }
sawine@5: 
sawine@5: (function(){
sawine@5: 	var html = document.documentElement,
sawine@5: 		matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;
sawine@5: 
sawine@5: 	if ( matches ) {
sawine@5: 		// Check to see if it's possible to do matchesSelector
sawine@5: 		// on a disconnected node (IE 9 fails this)
sawine@5: 		var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
sawine@5: 			pseudoWorks = false;
sawine@5: 
sawine@5: 		try {
sawine@5: 			// This should fail with an exception
sawine@5: 			// Gecko does not error, returns false instead
sawine@5: 			matches.call( document.documentElement, "[test!='']:sizzle" );
sawine@5: 	
sawine@5: 		} catch( pseudoError ) {
sawine@5: 			pseudoWorks = true;
sawine@5: 		}
sawine@5: 
sawine@5: 		Sizzle.matchesSelector = function( node, expr ) {
sawine@5: 			// Make sure that attribute selectors are quoted
sawine@5: 			expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
sawine@5: 
sawine@5: 			if ( !Sizzle.isXML( node ) ) {
sawine@5: 				try { 
sawine@5: 					if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
sawine@5: 						var ret = matches.call( node, expr );
sawine@5: 
sawine@5: 						// IE 9's matchesSelector returns false on disconnected nodes
sawine@5: 						if ( ret || !disconnectedMatch ||
sawine@5: 								// As well, disconnected nodes are said to be in a document
sawine@5: 								// fragment in IE 9, so check for that
sawine@5: 								node.document && node.document.nodeType !== 11 ) {
sawine@5: 							return ret;
sawine@5: 						}
sawine@5: 					}
sawine@5: 				} catch(e) {}
sawine@5: 			}
sawine@5: 
sawine@5: 			return Sizzle(expr, null, null, [node]).length > 0;
sawine@5: 		};
sawine@5: 	}
sawine@5: })();
sawine@5: 
sawine@5: (function(){
sawine@5: 	var div = document.createElement("div");
sawine@5: 
sawine@5: 	div.innerHTML = "<div class='test e'></div><div class='test'></div>";
sawine@5: 
sawine@5: 	// Opera can't find a second classname (in 9.6)
sawine@5: 	// Also, make sure that getElementsByClassName actually exists
sawine@5: 	if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
sawine@5: 		return;
sawine@5: 	}
sawine@5: 
sawine@5: 	// Safari caches class attributes, doesn't catch changes (in 3.2)
sawine@5: 	div.lastChild.className = "e";
sawine@5: 
sawine@5: 	if ( div.getElementsByClassName("e").length === 1 ) {
sawine@5: 		return;
sawine@5: 	}
sawine@5: 	
sawine@5: 	Expr.order.splice(1, 0, "CLASS");
sawine@5: 	Expr.find.CLASS = function( match, context, isXML ) {
sawine@5: 		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
sawine@5: 			return context.getElementsByClassName(match[1]);
sawine@5: 		}
sawine@5: 	};
sawine@5: 
sawine@5: 	// release memory in IE
sawine@5: 	div = null;
sawine@5: })();
sawine@5: 
sawine@5: function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
sawine@5: 	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
sawine@5: 		var elem = checkSet[i];
sawine@5: 
sawine@5: 		if ( elem ) {
sawine@5: 			var match = false;
sawine@5: 
sawine@5: 			elem = elem[dir];
sawine@5: 
sawine@5: 			while ( elem ) {
sawine@5: 				if ( elem.sizcache === doneName ) {
sawine@5: 					match = checkSet[elem.sizset];
sawine@5: 					break;
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( elem.nodeType === 1 && !isXML ){
sawine@5: 					elem.sizcache = doneName;
sawine@5: 					elem.sizset = i;
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( elem.nodeName.toLowerCase() === cur ) {
sawine@5: 					match = elem;
sawine@5: 					break;
sawine@5: 				}
sawine@5: 
sawine@5: 				elem = elem[dir];
sawine@5: 			}
sawine@5: 
sawine@5: 			checkSet[i] = match;
sawine@5: 		}
sawine@5: 	}
sawine@5: }
sawine@5: 
sawine@5: function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
sawine@5: 	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
sawine@5: 		var elem = checkSet[i];
sawine@5: 
sawine@5: 		if ( elem ) {
sawine@5: 			var match = false;
sawine@5: 			
sawine@5: 			elem = elem[dir];
sawine@5: 
sawine@5: 			while ( elem ) {
sawine@5: 				if ( elem.sizcache === doneName ) {
sawine@5: 					match = checkSet[elem.sizset];
sawine@5: 					break;
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( elem.nodeType === 1 ) {
sawine@5: 					if ( !isXML ) {
sawine@5: 						elem.sizcache = doneName;
sawine@5: 						elem.sizset = i;
sawine@5: 					}
sawine@5: 
sawine@5: 					if ( typeof cur !== "string" ) {
sawine@5: 						if ( elem === cur ) {
sawine@5: 							match = true;
sawine@5: 							break;
sawine@5: 						}
sawine@5: 
sawine@5: 					} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
sawine@5: 						match = elem;
sawine@5: 						break;
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				elem = elem[dir];
sawine@5: 			}
sawine@5: 
sawine@5: 			checkSet[i] = match;
sawine@5: 		}
sawine@5: 	}
sawine@5: }
sawine@5: 
sawine@5: if ( document.documentElement.contains ) {
sawine@5: 	Sizzle.contains = function( a, b ) {
sawine@5: 		return a !== b && (a.contains ? a.contains(b) : true);
sawine@5: 	};
sawine@5: 
sawine@5: } else if ( document.documentElement.compareDocumentPosition ) {
sawine@5: 	Sizzle.contains = function( a, b ) {
sawine@5: 		return !!(a.compareDocumentPosition(b) & 16);
sawine@5: 	};
sawine@5: 
sawine@5: } else {
sawine@5: 	Sizzle.contains = function() {
sawine@5: 		return false;
sawine@5: 	};
sawine@5: }
sawine@5: 
sawine@5: Sizzle.isXML = function( elem ) {
sawine@5: 	// documentElement is verified for cases where it doesn't yet exist
sawine@5: 	// (such as loading iframes in IE - #4833) 
sawine@5: 	var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
sawine@5: 
sawine@5: 	return documentElement ? documentElement.nodeName !== "HTML" : false;
sawine@5: };
sawine@5: 
sawine@5: var posProcess = function( selector, context ) {
sawine@5: 	var match,
sawine@5: 		tmpSet = [],
sawine@5: 		later = "",
sawine@5: 		root = context.nodeType ? [context] : context;
sawine@5: 
sawine@5: 	// Position selectors must be done after the filter
sawine@5: 	// And so must :not(positional) so we move all PSEUDOs to the end
sawine@5: 	while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
sawine@5: 		later += match[0];
sawine@5: 		selector = selector.replace( Expr.match.PSEUDO, "" );
sawine@5: 	}
sawine@5: 
sawine@5: 	selector = Expr.relative[selector] ? selector + "*" : selector;
sawine@5: 
sawine@5: 	for ( var i = 0, l = root.length; i < l; i++ ) {
sawine@5: 		Sizzle( selector, root[i], tmpSet );
sawine@5: 	}
sawine@5: 
sawine@5: 	return Sizzle.filter( later, tmpSet );
sawine@5: };
sawine@5: 
sawine@5: // EXPOSE
sawine@5: jQuery.find = Sizzle;
sawine@5: jQuery.expr = Sizzle.selectors;
sawine@5: jQuery.expr[":"] = jQuery.expr.filters;
sawine@5: jQuery.unique = Sizzle.uniqueSort;
sawine@5: jQuery.text = Sizzle.getText;
sawine@5: jQuery.isXMLDoc = Sizzle.isXML;
sawine@5: jQuery.contains = Sizzle.contains;
sawine@5: 
sawine@5: 
sawine@5: })();
sawine@5: 
sawine@5: 
sawine@5: var runtil = /Until$/,
sawine@5: 	rparentsprev = /^(?:parents|prevUntil|prevAll)/,
sawine@5: 	// Note: This RegExp should be improved, or likely pulled from Sizzle
sawine@5: 	rmultiselector = /,/,
sawine@5: 	isSimple = /^.[^:#\[\.,]*$/,
sawine@5: 	slice = Array.prototype.slice,
sawine@5: 	POS = jQuery.expr.match.POS,
sawine@5: 	// methods guaranteed to produce a unique set when starting from a unique set
sawine@5: 	guaranteedUnique = {
sawine@5: 		children: true,
sawine@5: 		contents: true,
sawine@5: 		next: true,
sawine@5: 		prev: true
sawine@5: 	};
sawine@5: 
sawine@5: jQuery.fn.extend({
sawine@5: 	find: function( selector ) {
sawine@5: 		var self = this,
sawine@5: 			i, l;
sawine@5: 
sawine@5: 		if ( typeof selector !== "string" ) {
sawine@5: 			return jQuery( selector ).filter(function() {
sawine@5: 				for ( i = 0, l = self.length; i < l; i++ ) {
sawine@5: 					if ( jQuery.contains( self[ i ], this ) ) {
sawine@5: 						return true;
sawine@5: 					}
sawine@5: 				}
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		var ret = this.pushStack( "", "find", selector ),
sawine@5: 			length, n, r;
sawine@5: 
sawine@5: 		for ( i = 0, l = this.length; i < l; i++ ) {
sawine@5: 			length = ret.length;
sawine@5: 			jQuery.find( selector, this[i], ret );
sawine@5: 
sawine@5: 			if ( i > 0 ) {
sawine@5: 				// Make sure that the results are unique
sawine@5: 				for ( n = length; n < ret.length; n++ ) {
sawine@5: 					for ( r = 0; r < length; r++ ) {
sawine@5: 						if ( ret[r] === ret[n] ) {
sawine@5: 							ret.splice(n--, 1);
sawine@5: 							break;
sawine@5: 						}
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return ret;
sawine@5: 	},
sawine@5: 
sawine@5: 	has: function( target ) {
sawine@5: 		var targets = jQuery( target );
sawine@5: 		return this.filter(function() {
sawine@5: 			for ( var i = 0, l = targets.length; i < l; i++ ) {
sawine@5: 				if ( jQuery.contains( this, targets[i] ) ) {
sawine@5: 					return true;
sawine@5: 				}
sawine@5: 			}
sawine@5: 		});
sawine@5: 	},
sawine@5: 
sawine@5: 	not: function( selector ) {
sawine@5: 		return this.pushStack( winnow(this, selector, false), "not", selector);
sawine@5: 	},
sawine@5: 
sawine@5: 	filter: function( selector ) {
sawine@5: 		return this.pushStack( winnow(this, selector, true), "filter", selector );
sawine@5: 	},
sawine@5: 
sawine@5: 	is: function( selector ) {
sawine@5: 		return !!selector && ( typeof selector === "string" ?
sawine@5: 			jQuery.filter( selector, this ).length > 0 :
sawine@5: 			this.filter( selector ).length > 0 );
sawine@5: 	},
sawine@5: 
sawine@5: 	closest: function( selectors, context ) {
sawine@5: 		var ret = [], i, l, cur = this[0];
sawine@5: 		
sawine@5: 		// Array
sawine@5: 		if ( jQuery.isArray( selectors ) ) {
sawine@5: 			var match, selector,
sawine@5: 				matches = {},
sawine@5: 				level = 1;
sawine@5: 
sawine@5: 			if ( cur && selectors.length ) {
sawine@5: 				for ( i = 0, l = selectors.length; i < l; i++ ) {
sawine@5: 					selector = selectors[i];
sawine@5: 
sawine@5: 					if ( !matches[ selector ] ) {
sawine@5: 						matches[ selector ] = POS.test( selector ) ?
sawine@5: 							jQuery( selector, context || this.context ) :
sawine@5: 							selector;
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				while ( cur && cur.ownerDocument && cur !== context ) {
sawine@5: 					for ( selector in matches ) {
sawine@5: 						match = matches[ selector ];
sawine@5: 
sawine@5: 						if ( match.jquery ? match.index( cur ) > -1 : jQuery( cur ).is( match ) ) {
sawine@5: 							ret.push({ selector: selector, elem: cur, level: level });
sawine@5: 						}
sawine@5: 					}
sawine@5: 
sawine@5: 					cur = cur.parentNode;
sawine@5: 					level++;
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			return ret;
sawine@5: 		}
sawine@5: 
sawine@5: 		// String
sawine@5: 		var pos = POS.test( selectors ) || typeof selectors !== "string" ?
sawine@5: 				jQuery( selectors, context || this.context ) :
sawine@5: 				0;
sawine@5: 
sawine@5: 		for ( i = 0, l = this.length; i < l; i++ ) {
sawine@5: 			cur = this[i];
sawine@5: 
sawine@5: 			while ( cur ) {
sawine@5: 				if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
sawine@5: 					ret.push( cur );
sawine@5: 					break;
sawine@5: 
sawine@5: 				} else {
sawine@5: 					cur = cur.parentNode;
sawine@5: 					if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) {
sawine@5: 						break;
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
sawine@5: 
sawine@5: 		return this.pushStack( ret, "closest", selectors );
sawine@5: 	},
sawine@5: 
sawine@5: 	// Determine the position of an element within
sawine@5: 	// the matched set of elements
sawine@5: 	index: function( elem ) {
sawine@5: 
sawine@5: 		// No argument, return index in parent
sawine@5: 		if ( !elem ) {
sawine@5: 			return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1;
sawine@5: 		}
sawine@5: 
sawine@5: 		// index in selector
sawine@5: 		if ( typeof elem === "string" ) {
sawine@5: 			return jQuery.inArray( this[0], jQuery( elem ) );
sawine@5: 		}
sawine@5: 
sawine@5: 		// Locate the position of the desired element
sawine@5: 		return jQuery.inArray(
sawine@5: 			// If it receives a jQuery object, the first element is used
sawine@5: 			elem.jquery ? elem[0] : elem, this );
sawine@5: 	},
sawine@5: 
sawine@5: 	add: function( selector, context ) {
sawine@5: 		var set = typeof selector === "string" ?
sawine@5: 				jQuery( selector, context ) :
sawine@5: 				jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
sawine@5: 			all = jQuery.merge( this.get(), set );
sawine@5: 
sawine@5: 		return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
sawine@5: 			all :
sawine@5: 			jQuery.unique( all ) );
sawine@5: 	},
sawine@5: 
sawine@5: 	andSelf: function() {
sawine@5: 		return this.add( this.prevObject );
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: // A painfully simple check to see if an element is disconnected
sawine@5: // from a document (should be improved, where feasible).
sawine@5: function isDisconnected( node ) {
sawine@5: 	return !node || !node.parentNode || node.parentNode.nodeType === 11;
sawine@5: }
sawine@5: 
sawine@5: jQuery.each({
sawine@5: 	parent: function( elem ) {
sawine@5: 		var parent = elem.parentNode;
sawine@5: 		return parent && parent.nodeType !== 11 ? parent : null;
sawine@5: 	},
sawine@5: 	parents: function( elem ) {
sawine@5: 		return jQuery.dir( elem, "parentNode" );
sawine@5: 	},
sawine@5: 	parentsUntil: function( elem, i, until ) {
sawine@5: 		return jQuery.dir( elem, "parentNode", until );
sawine@5: 	},
sawine@5: 	next: function( elem ) {
sawine@5: 		return jQuery.nth( elem, 2, "nextSibling" );
sawine@5: 	},
sawine@5: 	prev: function( elem ) {
sawine@5: 		return jQuery.nth( elem, 2, "previousSibling" );
sawine@5: 	},
sawine@5: 	nextAll: function( elem ) {
sawine@5: 		return jQuery.dir( elem, "nextSibling" );
sawine@5: 	},
sawine@5: 	prevAll: function( elem ) {
sawine@5: 		return jQuery.dir( elem, "previousSibling" );
sawine@5: 	},
sawine@5: 	nextUntil: function( elem, i, until ) {
sawine@5: 		return jQuery.dir( elem, "nextSibling", until );
sawine@5: 	},
sawine@5: 	prevUntil: function( elem, i, until ) {
sawine@5: 		return jQuery.dir( elem, "previousSibling", until );
sawine@5: 	},
sawine@5: 	siblings: function( elem ) {
sawine@5: 		return jQuery.sibling( elem.parentNode.firstChild, elem );
sawine@5: 	},
sawine@5: 	children: function( elem ) {
sawine@5: 		return jQuery.sibling( elem.firstChild );
sawine@5: 	},
sawine@5: 	contents: function( elem ) {
sawine@5: 		return jQuery.nodeName( elem, "iframe" ) ?
sawine@5: 			elem.contentDocument || elem.contentWindow.document :
sawine@5: 			jQuery.makeArray( elem.childNodes );
sawine@5: 	}
sawine@5: }, function( name, fn ) {
sawine@5: 	jQuery.fn[ name ] = function( until, selector ) {
sawine@5: 		var ret = jQuery.map( this, fn, until ),
sawine@5: 			// The variable 'args' was introduced in
sawine@5: 			// https://github.com/jquery/jquery/commit/52a0238
sawine@5: 			// to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
sawine@5: 			// http://code.google.com/p/v8/issues/detail?id=1050
sawine@5: 			args = slice.call(arguments);
sawine@5: 
sawine@5: 		if ( !runtil.test( name ) ) {
sawine@5: 			selector = until;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( selector && typeof selector === "string" ) {
sawine@5: 			ret = jQuery.filter( selector, ret );
sawine@5: 		}
sawine@5: 
sawine@5: 		ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
sawine@5: 
sawine@5: 		if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
sawine@5: 			ret = ret.reverse();
sawine@5: 		}
sawine@5: 
sawine@5: 		return this.pushStack( ret, name, args.join(",") );
sawine@5: 	};
sawine@5: });
sawine@5: 
sawine@5: jQuery.extend({
sawine@5: 	filter: function( expr, elems, not ) {
sawine@5: 		if ( not ) {
sawine@5: 			expr = ":not(" + expr + ")";
sawine@5: 		}
sawine@5: 
sawine@5: 		return elems.length === 1 ?
sawine@5: 			jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
sawine@5: 			jQuery.find.matches(expr, elems);
sawine@5: 	},
sawine@5: 
sawine@5: 	dir: function( elem, dir, until ) {
sawine@5: 		var matched = [],
sawine@5: 			cur = elem[ dir ];
sawine@5: 
sawine@5: 		while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
sawine@5: 			if ( cur.nodeType === 1 ) {
sawine@5: 				matched.push( cur );
sawine@5: 			}
sawine@5: 			cur = cur[dir];
sawine@5: 		}
sawine@5: 		return matched;
sawine@5: 	},
sawine@5: 
sawine@5: 	nth: function( cur, result, dir, elem ) {
sawine@5: 		result = result || 1;
sawine@5: 		var num = 0;
sawine@5: 
sawine@5: 		for ( ; cur; cur = cur[dir] ) {
sawine@5: 			if ( cur.nodeType === 1 && ++num === result ) {
sawine@5: 				break;
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return cur;
sawine@5: 	},
sawine@5: 
sawine@5: 	sibling: function( n, elem ) {
sawine@5: 		var r = [];
sawine@5: 
sawine@5: 		for ( ; n; n = n.nextSibling ) {
sawine@5: 			if ( n.nodeType === 1 && n !== elem ) {
sawine@5: 				r.push( n );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return r;
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: // Implement the identical functionality for filter and not
sawine@5: function winnow( elements, qualifier, keep ) {
sawine@5: 
sawine@5: 	// Can't pass null or undefined to indexOf in Firefox 4
sawine@5: 	// Set to 0 to skip string check
sawine@5: 	qualifier = qualifier || 0;
sawine@5: 
sawine@5: 	if ( jQuery.isFunction( qualifier ) ) {
sawine@5: 		return jQuery.grep(elements, function( elem, i ) {
sawine@5: 			var retVal = !!qualifier.call( elem, i, elem );
sawine@5: 			return retVal === keep;
sawine@5: 		});
sawine@5: 
sawine@5: 	} else if ( qualifier.nodeType ) {
sawine@5: 		return jQuery.grep(elements, function( elem, i ) {
sawine@5: 			return (elem === qualifier) === keep;
sawine@5: 		});
sawine@5: 
sawine@5: 	} else if ( typeof qualifier === "string" ) {
sawine@5: 		var filtered = jQuery.grep(elements, function( elem ) {
sawine@5: 			return elem.nodeType === 1;
sawine@5: 		});
sawine@5: 
sawine@5: 		if ( isSimple.test( qualifier ) ) {
sawine@5: 			return jQuery.filter(qualifier, filtered, !keep);
sawine@5: 		} else {
sawine@5: 			qualifier = jQuery.filter( qualifier, filtered );
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	return jQuery.grep(elements, function( elem, i ) {
sawine@5: 		return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
sawine@5: 	});
sawine@5: }
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
sawine@5: 	rleadingWhitespace = /^\s+/,
sawine@5: 	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
sawine@5: 	rtagName = /<([\w:]+)/,
sawine@5: 	rtbody = /<tbody/i,
sawine@5: 	rhtml = /<|&#?\w+;/,
sawine@5: 	rnocache = /<(?:script|object|embed|option|style)/i,
sawine@5: 	// checked="checked" or checked
sawine@5: 	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
sawine@5: 	rscriptType = /\/(java|ecma)script/i,
sawine@5: 	rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/,
sawine@5: 	wrapMap = {
sawine@5: 		option: [ 1, "<select multiple='multiple'>", "</select>" ],
sawine@5: 		legend: [ 1, "<fieldset>", "</fieldset>" ],
sawine@5: 		thead: [ 1, "<table>", "</table>" ],
sawine@5: 		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
sawine@5: 		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
sawine@5: 		col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
sawine@5: 		area: [ 1, "<map>", "</map>" ],
sawine@5: 		_default: [ 0, "", "" ]
sawine@5: 	};
sawine@5: 
sawine@5: wrapMap.optgroup = wrapMap.option;
sawine@5: wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
sawine@5: wrapMap.th = wrapMap.td;
sawine@5: 
sawine@5: // IE can't serialize <link> and <script> tags normally
sawine@5: if ( !jQuery.support.htmlSerialize ) {
sawine@5: 	wrapMap._default = [ 1, "div<div>", "</div>" ];
sawine@5: }
sawine@5: 
sawine@5: jQuery.fn.extend({
sawine@5: 	text: function( text ) {
sawine@5: 		if ( jQuery.isFunction(text) ) {
sawine@5: 			return this.each(function(i) {
sawine@5: 				var self = jQuery( this );
sawine@5: 
sawine@5: 				self.text( text.call(this, i, self.text()) );
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( typeof text !== "object" && text !== undefined ) {
sawine@5: 			return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
sawine@5: 		}
sawine@5: 
sawine@5: 		return jQuery.text( this );
sawine@5: 	},
sawine@5: 
sawine@5: 	wrapAll: function( html ) {
sawine@5: 		if ( jQuery.isFunction( html ) ) {
sawine@5: 			return this.each(function(i) {
sawine@5: 				jQuery(this).wrapAll( html.call(this, i) );
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( this[0] ) {
sawine@5: 			// The elements to wrap the target around
sawine@5: 			var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
sawine@5: 
sawine@5: 			if ( this[0].parentNode ) {
sawine@5: 				wrap.insertBefore( this[0] );
sawine@5: 			}
sawine@5: 
sawine@5: 			wrap.map(function() {
sawine@5: 				var elem = this;
sawine@5: 
sawine@5: 				while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
sawine@5: 					elem = elem.firstChild;
sawine@5: 				}
sawine@5: 
sawine@5: 				return elem;
sawine@5: 			}).append( this );
sawine@5: 		}
sawine@5: 
sawine@5: 		return this;
sawine@5: 	},
sawine@5: 
sawine@5: 	wrapInner: function( html ) {
sawine@5: 		if ( jQuery.isFunction( html ) ) {
sawine@5: 			return this.each(function(i) {
sawine@5: 				jQuery(this).wrapInner( html.call(this, i) );
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		return this.each(function() {
sawine@5: 			var self = jQuery( this ),
sawine@5: 				contents = self.contents();
sawine@5: 
sawine@5: 			if ( contents.length ) {
sawine@5: 				contents.wrapAll( html );
sawine@5: 
sawine@5: 			} else {
sawine@5: 				self.append( html );
sawine@5: 			}
sawine@5: 		});
sawine@5: 	},
sawine@5: 
sawine@5: 	wrap: function( html ) {
sawine@5: 		return this.each(function() {
sawine@5: 			jQuery( this ).wrapAll( html );
sawine@5: 		});
sawine@5: 	},
sawine@5: 
sawine@5: 	unwrap: function() {
sawine@5: 		return this.parent().each(function() {
sawine@5: 			if ( !jQuery.nodeName( this, "body" ) ) {
sawine@5: 				jQuery( this ).replaceWith( this.childNodes );
sawine@5: 			}
sawine@5: 		}).end();
sawine@5: 	},
sawine@5: 
sawine@5: 	append: function() {
sawine@5: 		return this.domManip(arguments, true, function( elem ) {
sawine@5: 			if ( this.nodeType === 1 ) {
sawine@5: 				this.appendChild( elem );
sawine@5: 			}
sawine@5: 		});
sawine@5: 	},
sawine@5: 
sawine@5: 	prepend: function() {
sawine@5: 		return this.domManip(arguments, true, function( elem ) {
sawine@5: 			if ( this.nodeType === 1 ) {
sawine@5: 				this.insertBefore( elem, this.firstChild );
sawine@5: 			}
sawine@5: 		});
sawine@5: 	},
sawine@5: 
sawine@5: 	before: function() {
sawine@5: 		if ( this[0] && this[0].parentNode ) {
sawine@5: 			return this.domManip(arguments, false, function( elem ) {
sawine@5: 				this.parentNode.insertBefore( elem, this );
sawine@5: 			});
sawine@5: 		} else if ( arguments.length ) {
sawine@5: 			var set = jQuery(arguments[0]);
sawine@5: 			set.push.apply( set, this.toArray() );
sawine@5: 			return this.pushStack( set, "before", arguments );
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	after: function() {
sawine@5: 		if ( this[0] && this[0].parentNode ) {
sawine@5: 			return this.domManip(arguments, false, function( elem ) {
sawine@5: 				this.parentNode.insertBefore( elem, this.nextSibling );
sawine@5: 			});
sawine@5: 		} else if ( arguments.length ) {
sawine@5: 			var set = this.pushStack( this, "after", arguments );
sawine@5: 			set.push.apply( set, jQuery(arguments[0]).toArray() );
sawine@5: 			return set;
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	// keepData is for internal use only--do not document
sawine@5: 	remove: function( selector, keepData ) {
sawine@5: 		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
sawine@5: 			if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
sawine@5: 				if ( !keepData && elem.nodeType === 1 ) {
sawine@5: 					jQuery.cleanData( elem.getElementsByTagName("*") );
sawine@5: 					jQuery.cleanData( [ elem ] );
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( elem.parentNode ) {
sawine@5: 					elem.parentNode.removeChild( elem );
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return this;
sawine@5: 	},
sawine@5: 
sawine@5: 	empty: function() {
sawine@5: 		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
sawine@5: 			// Remove element nodes and prevent memory leaks
sawine@5: 			if ( elem.nodeType === 1 ) {
sawine@5: 				jQuery.cleanData( elem.getElementsByTagName("*") );
sawine@5: 			}
sawine@5: 
sawine@5: 			// Remove any remaining nodes
sawine@5: 			while ( elem.firstChild ) {
sawine@5: 				elem.removeChild( elem.firstChild );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return this;
sawine@5: 	},
sawine@5: 
sawine@5: 	clone: function( dataAndEvents, deepDataAndEvents ) {
sawine@5: 		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
sawine@5: 		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
sawine@5: 
sawine@5: 		return this.map( function () {
sawine@5: 			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
sawine@5: 		});
sawine@5: 	},
sawine@5: 
sawine@5: 	html: function( value ) {
sawine@5: 		if ( value === undefined ) {
sawine@5: 			return this[0] && this[0].nodeType === 1 ?
sawine@5: 				this[0].innerHTML.replace(rinlinejQuery, "") :
sawine@5: 				null;
sawine@5: 
sawine@5: 		// See if we can take a shortcut and just use innerHTML
sawine@5: 		} else if ( typeof value === "string" && !rnocache.test( value ) &&
sawine@5: 			(jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
sawine@5: 			!wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
sawine@5: 
sawine@5: 			value = value.replace(rxhtmlTag, "<$1></$2>");
sawine@5: 
sawine@5: 			try {
sawine@5: 				for ( var i = 0, l = this.length; i < l; i++ ) {
sawine@5: 					// Remove element nodes and prevent memory leaks
sawine@5: 					if ( this[i].nodeType === 1 ) {
sawine@5: 						jQuery.cleanData( this[i].getElementsByTagName("*") );
sawine@5: 						this[i].innerHTML = value;
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 			// If using innerHTML throws an exception, use the fallback method
sawine@5: 			} catch(e) {
sawine@5: 				this.empty().append( value );
sawine@5: 			}
sawine@5: 
sawine@5: 		} else if ( jQuery.isFunction( value ) ) {
sawine@5: 			this.each(function(i){
sawine@5: 				var self = jQuery( this );
sawine@5: 
sawine@5: 				self.html( value.call(this, i, self.html()) );
sawine@5: 			});
sawine@5: 
sawine@5: 		} else {
sawine@5: 			this.empty().append( value );
sawine@5: 		}
sawine@5: 
sawine@5: 		return this;
sawine@5: 	},
sawine@5: 
sawine@5: 	replaceWith: function( value ) {
sawine@5: 		if ( this[0] && this[0].parentNode ) {
sawine@5: 			// Make sure that the elements are removed from the DOM before they are inserted
sawine@5: 			// this can help fix replacing a parent with child elements
sawine@5: 			if ( jQuery.isFunction( value ) ) {
sawine@5: 				return this.each(function(i) {
sawine@5: 					var self = jQuery(this), old = self.html();
sawine@5: 					self.replaceWith( value.call( this, i, old ) );
sawine@5: 				});
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( typeof value !== "string" ) {
sawine@5: 				value = jQuery( value ).detach();
sawine@5: 			}
sawine@5: 
sawine@5: 			return this.each(function() {
sawine@5: 				var next = this.nextSibling,
sawine@5: 					parent = this.parentNode;
sawine@5: 
sawine@5: 				jQuery( this ).remove();
sawine@5: 
sawine@5: 				if ( next ) {
sawine@5: 					jQuery(next).before( value );
sawine@5: 				} else {
sawine@5: 					jQuery(parent).append( value );
sawine@5: 				}
sawine@5: 			});
sawine@5: 		} else {
sawine@5: 			return this.length ?
sawine@5: 				this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
sawine@5: 				this;
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	detach: function( selector ) {
sawine@5: 		return this.remove( selector, true );
sawine@5: 	},
sawine@5: 
sawine@5: 	domManip: function( args, table, callback ) {
sawine@5: 		var results, first, fragment, parent,
sawine@5: 			value = args[0],
sawine@5: 			scripts = [];
sawine@5: 
sawine@5: 		// We can't cloneNode fragments that contain checked, in WebKit
sawine@5: 		if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
sawine@5: 			return this.each(function() {
sawine@5: 				jQuery(this).domManip( args, table, callback, true );
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( jQuery.isFunction(value) ) {
sawine@5: 			return this.each(function(i) {
sawine@5: 				var self = jQuery(this);
sawine@5: 				args[0] = value.call(this, i, table ? self.html() : undefined);
sawine@5: 				self.domManip( args, table, callback );
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( this[0] ) {
sawine@5: 			parent = value && value.parentNode;
sawine@5: 
sawine@5: 			// If we're in a fragment, just use that instead of building a new one
sawine@5: 			if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
sawine@5: 				results = { fragment: parent };
sawine@5: 
sawine@5: 			} else {
sawine@5: 				results = jQuery.buildFragment( args, this, scripts );
sawine@5: 			}
sawine@5: 
sawine@5: 			fragment = results.fragment;
sawine@5: 
sawine@5: 			if ( fragment.childNodes.length === 1 ) {
sawine@5: 				first = fragment = fragment.firstChild;
sawine@5: 			} else {
sawine@5: 				first = fragment.firstChild;
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( first ) {
sawine@5: 				table = table && jQuery.nodeName( first, "tr" );
sawine@5: 
sawine@5: 				for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
sawine@5: 					callback.call(
sawine@5: 						table ?
sawine@5: 							root(this[i], first) :
sawine@5: 							this[i],
sawine@5: 						// Make sure that we do not leak memory by inadvertently discarding
sawine@5: 						// the original fragment (which might have attached data) instead of
sawine@5: 						// using it; in addition, use the original fragment object for the last
sawine@5: 						// item instead of first because it can end up being emptied incorrectly
sawine@5: 						// in certain situations (Bug #8070).
sawine@5: 						// Fragments from the fragment cache must always be cloned and never used
sawine@5: 						// in place.
sawine@5: 						results.cacheable || (l > 1 && i < lastIndex) ?
sawine@5: 							jQuery.clone( fragment, true, true ) :
sawine@5: 							fragment
sawine@5: 					);
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( scripts.length ) {
sawine@5: 				jQuery.each( scripts, evalScript );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return this;
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: function root( elem, cur ) {
sawine@5: 	return jQuery.nodeName(elem, "table") ?
sawine@5: 		(elem.getElementsByTagName("tbody")[0] ||
sawine@5: 		elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
sawine@5: 		elem;
sawine@5: }
sawine@5: 
sawine@5: function cloneCopyEvent( src, dest ) {
sawine@5: 
sawine@5: 	if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
sawine@5: 		return;
sawine@5: 	}
sawine@5: 
sawine@5: 	var internalKey = jQuery.expando,
sawine@5: 		oldData = jQuery.data( src ),
sawine@5: 		curData = jQuery.data( dest, oldData );
sawine@5: 
sawine@5: 	// Switch to use the internal data object, if it exists, for the next
sawine@5: 	// stage of data copying
sawine@5: 	if ( (oldData = oldData[ internalKey ]) ) {
sawine@5: 		var events = oldData.events;
sawine@5: 				curData = curData[ internalKey ] = jQuery.extend({}, oldData);
sawine@5: 
sawine@5: 		if ( events ) {
sawine@5: 			delete curData.handle;
sawine@5: 			curData.events = {};
sawine@5: 
sawine@5: 			for ( var type in events ) {
sawine@5: 				for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
sawine@5: 					jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 	}
sawine@5: }
sawine@5: 
sawine@5: function cloneFixAttributes( src, dest ) {
sawine@5: 	var nodeName;
sawine@5: 
sawine@5: 	// We do not need to do anything for non-Elements
sawine@5: 	if ( dest.nodeType !== 1 ) {
sawine@5: 		return;
sawine@5: 	}
sawine@5: 
sawine@5: 	// clearAttributes removes the attributes, which we don't want,
sawine@5: 	// but also removes the attachEvent events, which we *do* want
sawine@5: 	if ( dest.clearAttributes ) {
sawine@5: 		dest.clearAttributes();
sawine@5: 	}
sawine@5: 
sawine@5: 	// mergeAttributes, in contrast, only merges back on the
sawine@5: 	// original attributes, not the events
sawine@5: 	if ( dest.mergeAttributes ) {
sawine@5: 		dest.mergeAttributes( src );
sawine@5: 	}
sawine@5: 
sawine@5: 	nodeName = dest.nodeName.toLowerCase();
sawine@5: 
sawine@5: 	// IE6-8 fail to clone children inside object elements that use
sawine@5: 	// the proprietary classid attribute value (rather than the type
sawine@5: 	// attribute) to identify the type of content to display
sawine@5: 	if ( nodeName === "object" ) {
sawine@5: 		dest.outerHTML = src.outerHTML;
sawine@5: 
sawine@5: 	} else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
sawine@5: 		// IE6-8 fails to persist the checked state of a cloned checkbox
sawine@5: 		// or radio button. Worse, IE6-7 fail to give the cloned element
sawine@5: 		// a checked appearance if the defaultChecked value isn't also set
sawine@5: 		if ( src.checked ) {
sawine@5: 			dest.defaultChecked = dest.checked = src.checked;
sawine@5: 		}
sawine@5: 
sawine@5: 		// IE6-7 get confused and end up setting the value of a cloned
sawine@5: 		// checkbox/radio button to an empty string instead of "on"
sawine@5: 		if ( dest.value !== src.value ) {
sawine@5: 			dest.value = src.value;
sawine@5: 		}
sawine@5: 
sawine@5: 	// IE6-8 fails to return the selected option to the default selected
sawine@5: 	// state when cloning options
sawine@5: 	} else if ( nodeName === "option" ) {
sawine@5: 		dest.selected = src.defaultSelected;
sawine@5: 
sawine@5: 	// IE6-8 fails to set the defaultValue to the correct value when
sawine@5: 	// cloning other types of input fields
sawine@5: 	} else if ( nodeName === "input" || nodeName === "textarea" ) {
sawine@5: 		dest.defaultValue = src.defaultValue;
sawine@5: 	}
sawine@5: 
sawine@5: 	// Event data gets referenced instead of copied if the expando
sawine@5: 	// gets copied too
sawine@5: 	dest.removeAttribute( jQuery.expando );
sawine@5: }
sawine@5: 
sawine@5: jQuery.buildFragment = function( args, nodes, scripts ) {
sawine@5: 	var fragment, cacheable, cacheresults, doc;
sawine@5: 
sawine@5:   // nodes may contain either an explicit document object,
sawine@5:   // a jQuery collection or context object.
sawine@5:   // If nodes[0] contains a valid object to assign to doc
sawine@5:   if ( nodes && nodes[0] ) {
sawine@5:     doc = nodes[0].ownerDocument || nodes[0];
sawine@5:   }
sawine@5: 
sawine@5:   // Ensure that an attr object doesn't incorrectly stand in as a document object
sawine@5: 	// Chrome and Firefox seem to allow this to occur and will throw exception
sawine@5: 	// Fixes #8950
sawine@5: 	if ( !doc.createDocumentFragment ) {
sawine@5: 		doc = document;
sawine@5: 	}
sawine@5: 
sawine@5: 	// Only cache "small" (1/2 KB) HTML strings that are associated with the main document
sawine@5: 	// Cloning options loses the selected state, so don't cache them
sawine@5: 	// IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
sawine@5: 	// Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
sawine@5: 	if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
sawine@5: 		args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
sawine@5: 
sawine@5: 		cacheable = true;
sawine@5: 
sawine@5: 		cacheresults = jQuery.fragments[ args[0] ];
sawine@5: 		if ( cacheresults && cacheresults !== 1 ) {
sawine@5: 			fragment = cacheresults;
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	if ( !fragment ) {
sawine@5: 		fragment = doc.createDocumentFragment();
sawine@5: 		jQuery.clean( args, doc, fragment, scripts );
sawine@5: 	}
sawine@5: 
sawine@5: 	if ( cacheable ) {
sawine@5: 		jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
sawine@5: 	}
sawine@5: 
sawine@5: 	return { fragment: fragment, cacheable: cacheable };
sawine@5: };
sawine@5: 
sawine@5: jQuery.fragments = {};
sawine@5: 
sawine@5: jQuery.each({
sawine@5: 	appendTo: "append",
sawine@5: 	prependTo: "prepend",
sawine@5: 	insertBefore: "before",
sawine@5: 	insertAfter: "after",
sawine@5: 	replaceAll: "replaceWith"
sawine@5: }, function( name, original ) {
sawine@5: 	jQuery.fn[ name ] = function( selector ) {
sawine@5: 		var ret = [],
sawine@5: 			insert = jQuery( selector ),
sawine@5: 			parent = this.length === 1 && this[0].parentNode;
sawine@5: 
sawine@5: 		if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
sawine@5: 			insert[ original ]( this[0] );
sawine@5: 			return this;
sawine@5: 
sawine@5: 		} else {
sawine@5: 			for ( var i = 0, l = insert.length; i < l; i++ ) {
sawine@5: 				var elems = (i > 0 ? this.clone(true) : this).get();
sawine@5: 				jQuery( insert[i] )[ original ]( elems );
sawine@5: 				ret = ret.concat( elems );
sawine@5: 			}
sawine@5: 
sawine@5: 			return this.pushStack( ret, name, insert.selector );
sawine@5: 		}
sawine@5: 	};
sawine@5: });
sawine@5: 
sawine@5: function getAll( elem ) {
sawine@5: 	if ( "getElementsByTagName" in elem ) {
sawine@5: 		return elem.getElementsByTagName( "*" );
sawine@5: 
sawine@5: 	} else if ( "querySelectorAll" in elem ) {
sawine@5: 		return elem.querySelectorAll( "*" );
sawine@5: 
sawine@5: 	} else {
sawine@5: 		return [];
sawine@5: 	}
sawine@5: }
sawine@5: 
sawine@5: // Used in clean, fixes the defaultChecked property
sawine@5: function fixDefaultChecked( elem ) {
sawine@5: 	if ( elem.type === "checkbox" || elem.type === "radio" ) {
sawine@5: 		elem.defaultChecked = elem.checked;
sawine@5: 	}
sawine@5: }
sawine@5: // Finds all inputs and passes them to fixDefaultChecked
sawine@5: function findInputs( elem ) {
sawine@5: 	if ( jQuery.nodeName( elem, "input" ) ) {
sawine@5: 		fixDefaultChecked( elem );
sawine@5: 	} else if ( "getElementsByTagName" in elem ) {
sawine@5: 		jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
sawine@5: 	}
sawine@5: }
sawine@5: 
sawine@5: jQuery.extend({
sawine@5: 	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
sawine@5: 		var clone = elem.cloneNode(true),
sawine@5: 				srcElements,
sawine@5: 				destElements,
sawine@5: 				i;
sawine@5: 
sawine@5: 		if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
sawine@5: 				(elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
sawine@5: 			// IE copies events bound via attachEvent when using cloneNode.
sawine@5: 			// Calling detachEvent on the clone will also remove the events
sawine@5: 			// from the original. In order to get around this, we use some
sawine@5: 			// proprietary methods to clear the events. Thanks to MooTools
sawine@5: 			// guys for this hotness.
sawine@5: 
sawine@5: 			cloneFixAttributes( elem, clone );
sawine@5: 
sawine@5: 			// Using Sizzle here is crazy slow, so we use getElementsByTagName
sawine@5: 			// instead
sawine@5: 			srcElements = getAll( elem );
sawine@5: 			destElements = getAll( clone );
sawine@5: 
sawine@5: 			// Weird iteration because IE will replace the length property
sawine@5: 			// with an element if you are cloning the body and one of the
sawine@5: 			// elements on the page has a name or id of "length"
sawine@5: 			for ( i = 0; srcElements[i]; ++i ) {
sawine@5: 				// Ensure that the destination node is not null; Fixes #9587
sawine@5: 				if ( destElements[i] ) {
sawine@5: 					cloneFixAttributes( srcElements[i], destElements[i] );
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		// Copy the events from the original to the clone
sawine@5: 		if ( dataAndEvents ) {
sawine@5: 			cloneCopyEvent( elem, clone );
sawine@5: 
sawine@5: 			if ( deepDataAndEvents ) {
sawine@5: 				srcElements = getAll( elem );
sawine@5: 				destElements = getAll( clone );
sawine@5: 
sawine@5: 				for ( i = 0; srcElements[i]; ++i ) {
sawine@5: 					cloneCopyEvent( srcElements[i], destElements[i] );
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		srcElements = destElements = null;
sawine@5: 
sawine@5: 		// Return the cloned set
sawine@5: 		return clone;
sawine@5: 	},
sawine@5: 
sawine@5: 	clean: function( elems, context, fragment, scripts ) {
sawine@5: 		var checkScriptType;
sawine@5: 
sawine@5: 		context = context || document;
sawine@5: 
sawine@5: 		// !context.createElement fails in IE with an error but returns typeof 'object'
sawine@5: 		if ( typeof context.createElement === "undefined" ) {
sawine@5: 			context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
sawine@5: 		}
sawine@5: 
sawine@5: 		var ret = [], j;
sawine@5: 
sawine@5: 		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
sawine@5: 			if ( typeof elem === "number" ) {
sawine@5: 				elem += "";
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( !elem ) {
sawine@5: 				continue;
sawine@5: 			}
sawine@5: 
sawine@5: 			// Convert html string into DOM nodes
sawine@5: 			if ( typeof elem === "string" ) {
sawine@5: 				if ( !rhtml.test( elem ) ) {
sawine@5: 					elem = context.createTextNode( elem );
sawine@5: 				} else {
sawine@5: 					// Fix "XHTML"-style tags in all browsers
sawine@5: 					elem = elem.replace(rxhtmlTag, "<$1></$2>");
sawine@5: 
sawine@5: 					// Trim whitespace, otherwise indexOf won't work as expected
sawine@5: 					var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
sawine@5: 						wrap = wrapMap[ tag ] || wrapMap._default,
sawine@5: 						depth = wrap[0],
sawine@5: 						div = context.createElement("div");
sawine@5: 
sawine@5: 					// Go to html and back, then peel off extra wrappers
sawine@5: 					div.innerHTML = wrap[1] + elem + wrap[2];
sawine@5: 
sawine@5: 					// Move to the right depth
sawine@5: 					while ( depth-- ) {
sawine@5: 						div = div.lastChild;
sawine@5: 					}
sawine@5: 
sawine@5: 					// Remove IE's autoinserted <tbody> from table fragments
sawine@5: 					if ( !jQuery.support.tbody ) {
sawine@5: 
sawine@5: 						// String was a <table>, *may* have spurious <tbody>
sawine@5: 						var hasBody = rtbody.test(elem),
sawine@5: 							tbody = tag === "table" && !hasBody ?
sawine@5: 								div.firstChild && div.firstChild.childNodes :
sawine@5: 
sawine@5: 								// String was a bare <thead> or <tfoot>
sawine@5: 								wrap[1] === "<table>" && !hasBody ?
sawine@5: 									div.childNodes :
sawine@5: 									[];
sawine@5: 
sawine@5: 						for ( j = tbody.length - 1; j >= 0 ; --j ) {
sawine@5: 							if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
sawine@5: 								tbody[ j ].parentNode.removeChild( tbody[ j ] );
sawine@5: 							}
sawine@5: 						}
sawine@5: 					}
sawine@5: 
sawine@5: 					// IE completely kills leading whitespace when innerHTML is used
sawine@5: 					if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
sawine@5: 						div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
sawine@5: 					}
sawine@5: 
sawine@5: 					elem = div.childNodes;
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			// Resets defaultChecked for any radios and checkboxes
sawine@5: 			// about to be appended to the DOM in IE 6/7 (#8060)
sawine@5: 			var len;
sawine@5: 			if ( !jQuery.support.appendChecked ) {
sawine@5: 				if ( elem[0] && typeof (len = elem.length) === "number" ) {
sawine@5: 					for ( j = 0; j < len; j++ ) {
sawine@5: 						findInputs( elem[j] );
sawine@5: 					}
sawine@5: 				} else {
sawine@5: 					findInputs( elem );
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( elem.nodeType ) {
sawine@5: 				ret.push( elem );
sawine@5: 			} else {
sawine@5: 				ret = jQuery.merge( ret, elem );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( fragment ) {
sawine@5: 			checkScriptType = function( elem ) {
sawine@5: 				return !elem.type || rscriptType.test( elem.type );
sawine@5: 			};
sawine@5: 			for ( i = 0; ret[i]; i++ ) {
sawine@5: 				if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
sawine@5: 					scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
sawine@5: 
sawine@5: 				} else {
sawine@5: 					if ( ret[i].nodeType === 1 ) {
sawine@5: 						var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType );
sawine@5: 
sawine@5: 						ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
sawine@5: 					}
sawine@5: 					fragment.appendChild( ret[i] );
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return ret;
sawine@5: 	},
sawine@5: 
sawine@5: 	cleanData: function( elems ) {
sawine@5: 		var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
sawine@5: 			deleteExpando = jQuery.support.deleteExpando;
sawine@5: 
sawine@5: 		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
sawine@5: 			if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
sawine@5: 				continue;
sawine@5: 			}
sawine@5: 
sawine@5: 			id = elem[ jQuery.expando ];
sawine@5: 
sawine@5: 			if ( id ) {
sawine@5: 				data = cache[ id ] && cache[ id ][ internalKey ];
sawine@5: 
sawine@5: 				if ( data && data.events ) {
sawine@5: 					for ( var type in data.events ) {
sawine@5: 						if ( special[ type ] ) {
sawine@5: 							jQuery.event.remove( elem, type );
sawine@5: 
sawine@5: 						// This is a shortcut to avoid jQuery.event.remove's overhead
sawine@5: 						} else {
sawine@5: 							jQuery.removeEvent( elem, type, data.handle );
sawine@5: 						}
sawine@5: 					}
sawine@5: 
sawine@5: 					// Null the DOM reference to avoid IE6/7/8 leak (#7054)
sawine@5: 					if ( data.handle ) {
sawine@5: 						data.handle.elem = null;
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( deleteExpando ) {
sawine@5: 					delete elem[ jQuery.expando ];
sawine@5: 
sawine@5: 				} else if ( elem.removeAttribute ) {
sawine@5: 					elem.removeAttribute( jQuery.expando );
sawine@5: 				}
sawine@5: 
sawine@5: 				delete cache[ id ];
sawine@5: 			}
sawine@5: 		}
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: function evalScript( i, elem ) {
sawine@5: 	if ( elem.src ) {
sawine@5: 		jQuery.ajax({
sawine@5: 			url: elem.src,
sawine@5: 			async: false,
sawine@5: 			dataType: "script"
sawine@5: 		});
sawine@5: 	} else {
sawine@5: 		jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "/*$0*/" ) );
sawine@5: 	}
sawine@5: 
sawine@5: 	if ( elem.parentNode ) {
sawine@5: 		elem.parentNode.removeChild( elem );
sawine@5: 	}
sawine@5: }
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: var ralpha = /alpha\([^)]*\)/i,
sawine@5: 	ropacity = /opacity=([^)]*)/,
sawine@5: 	// fixed for IE9, see #8346
sawine@5: 	rupper = /([A-Z]|^ms)/g,
sawine@5: 	rnumpx = /^-?\d+(?:px)?$/i,
sawine@5: 	rnum = /^-?\d/,
sawine@5: 	rrelNum = /^([\-+])=([\-+.\de]+)/,
sawine@5: 
sawine@5: 	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
sawine@5: 	cssWidth = [ "Left", "Right" ],
sawine@5: 	cssHeight = [ "Top", "Bottom" ],
sawine@5: 	curCSS,
sawine@5: 
sawine@5: 	getComputedStyle,
sawine@5: 	currentStyle;
sawine@5: 
sawine@5: jQuery.fn.css = function( name, value ) {
sawine@5: 	// Setting 'undefined' is a no-op
sawine@5: 	if ( arguments.length === 2 && value === undefined ) {
sawine@5: 		return this;
sawine@5: 	}
sawine@5: 
sawine@5: 	return jQuery.access( this, name, value, true, function( elem, name, value ) {
sawine@5: 		return value !== undefined ?
sawine@5: 			jQuery.style( elem, name, value ) :
sawine@5: 			jQuery.css( elem, name );
sawine@5: 	});
sawine@5: };
sawine@5: 
sawine@5: jQuery.extend({
sawine@5: 	// Add in style property hooks for overriding the default
sawine@5: 	// behavior of getting and setting a style property
sawine@5: 	cssHooks: {
sawine@5: 		opacity: {
sawine@5: 			get: function( elem, computed ) {
sawine@5: 				if ( computed ) {
sawine@5: 					// We should always get a number back from opacity
sawine@5: 					var ret = curCSS( elem, "opacity", "opacity" );
sawine@5: 					return ret === "" ? "1" : ret;
sawine@5: 
sawine@5: 				} else {
sawine@5: 					return elem.style.opacity;
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	// Exclude the following css properties to add px
sawine@5: 	cssNumber: {
sawine@5: 		"fillOpacity": true,
sawine@5: 		"fontWeight": true,
sawine@5: 		"lineHeight": true,
sawine@5: 		"opacity": true,
sawine@5: 		"orphans": true,
sawine@5: 		"widows": true,
sawine@5: 		"zIndex": true,
sawine@5: 		"zoom": true
sawine@5: 	},
sawine@5: 
sawine@5: 	// Add in properties whose names you wish to fix before
sawine@5: 	// setting or getting the value
sawine@5: 	cssProps: {
sawine@5: 		// normalize float css property
sawine@5: 		"float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
sawine@5: 	},
sawine@5: 
sawine@5: 	// Get and set the style property on a DOM Node
sawine@5: 	style: function( elem, name, value, extra ) {
sawine@5: 		// Don't set styles on text and comment nodes
sawine@5: 		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
sawine@5: 			return;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Make sure that we're working with the right name
sawine@5: 		var ret, type, origName = jQuery.camelCase( name ),
sawine@5: 			style = elem.style, hooks = jQuery.cssHooks[ origName ];
sawine@5: 
sawine@5: 		name = jQuery.cssProps[ origName ] || origName;
sawine@5: 
sawine@5: 		// Check if we're setting a value
sawine@5: 		if ( value !== undefined ) {
sawine@5: 			type = typeof value;
sawine@5: 
sawine@5: 			// convert relative number strings (+= or -=) to relative numbers. #7345
sawine@5: 			if ( type === "string" && (ret = rrelNum.exec( value )) ) {
sawine@5: 				value = ( +( ret[1] + 1) * +ret[2] ) + parseFloat( jQuery.css( elem, name ) );
sawine@5: 				// Fixes bug #9237
sawine@5: 				type = "number";
sawine@5: 			}
sawine@5: 
sawine@5: 			// Make sure that NaN and null values aren't set. See: #7116
sawine@5: 			if ( value == null || type === "number" && isNaN( value ) ) {
sawine@5: 				return;
sawine@5: 			}
sawine@5: 
sawine@5: 			// If a number was passed in, add 'px' to the (except for certain CSS properties)
sawine@5: 			if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
sawine@5: 				value += "px";
sawine@5: 			}
sawine@5: 
sawine@5: 			// If a hook was provided, use that value, otherwise just set the specified value
sawine@5: 			if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
sawine@5: 				// Wrapped to prevent IE from throwing errors when 'invalid' values are provided
sawine@5: 				// Fixes bug #5509
sawine@5: 				try {
sawine@5: 					style[ name ] = value;
sawine@5: 				} catch(e) {}
sawine@5: 			}
sawine@5: 
sawine@5: 		} else {
sawine@5: 			// If a hook was provided get the non-computed value from there
sawine@5: 			if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
sawine@5: 				return ret;
sawine@5: 			}
sawine@5: 
sawine@5: 			// Otherwise just get the value from the style object
sawine@5: 			return style[ name ];
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	css: function( elem, name, extra ) {
sawine@5: 		var ret, hooks;
sawine@5: 
sawine@5: 		// Make sure that we're working with the right name
sawine@5: 		name = jQuery.camelCase( name );
sawine@5: 		hooks = jQuery.cssHooks[ name ];
sawine@5: 		name = jQuery.cssProps[ name ] || name;
sawine@5: 
sawine@5: 		// cssFloat needs a special treatment
sawine@5: 		if ( name === "cssFloat" ) {
sawine@5: 			name = "float";
sawine@5: 		}
sawine@5: 
sawine@5: 		// If a hook was provided get the computed value from there
sawine@5: 		if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
sawine@5: 			return ret;
sawine@5: 
sawine@5: 		// Otherwise, if a way to get the computed value exists, use that
sawine@5: 		} else if ( curCSS ) {
sawine@5: 			return curCSS( elem, name );
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	// A method for quickly swapping in/out CSS properties to get correct calculations
sawine@5: 	swap: function( elem, options, callback ) {
sawine@5: 		var old = {};
sawine@5: 
sawine@5: 		// Remember the old values, and insert the new ones
sawine@5: 		for ( var name in options ) {
sawine@5: 			old[ name ] = elem.style[ name ];
sawine@5: 			elem.style[ name ] = options[ name ];
sawine@5: 		}
sawine@5: 
sawine@5: 		callback.call( elem );
sawine@5: 
sawine@5: 		// Revert the old values
sawine@5: 		for ( name in options ) {
sawine@5: 			elem.style[ name ] = old[ name ];
sawine@5: 		}
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: // DEPRECATED, Use jQuery.css() instead
sawine@5: jQuery.curCSS = jQuery.css;
sawine@5: 
sawine@5: jQuery.each(["height", "width"], function( i, name ) {
sawine@5: 	jQuery.cssHooks[ name ] = {
sawine@5: 		get: function( elem, computed, extra ) {
sawine@5: 			var val;
sawine@5: 
sawine@5: 			if ( computed ) {
sawine@5: 				if ( elem.offsetWidth !== 0 ) {
sawine@5: 					return getWH( elem, name, extra );
sawine@5: 				} else {
sawine@5: 					jQuery.swap( elem, cssShow, function() {
sawine@5: 						val = getWH( elem, name, extra );
sawine@5: 					});
sawine@5: 				}
sawine@5: 
sawine@5: 				return val;
sawine@5: 			}
sawine@5: 		},
sawine@5: 
sawine@5: 		set: function( elem, value ) {
sawine@5: 			if ( rnumpx.test( value ) ) {
sawine@5: 				// ignore negative width and height values #1599
sawine@5: 				value = parseFloat( value );
sawine@5: 
sawine@5: 				if ( value >= 0 ) {
sawine@5: 					return value + "px";
sawine@5: 				}
sawine@5: 
sawine@5: 			} else {
sawine@5: 				return value;
sawine@5: 			}
sawine@5: 		}
sawine@5: 	};
sawine@5: });
sawine@5: 
sawine@5: if ( !jQuery.support.opacity ) {
sawine@5: 	jQuery.cssHooks.opacity = {
sawine@5: 		get: function( elem, computed ) {
sawine@5: 			// IE uses filters for opacity
sawine@5: 			return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
sawine@5: 				( parseFloat( RegExp.$1 ) / 100 ) + "" :
sawine@5: 				computed ? "1" : "";
sawine@5: 		},
sawine@5: 
sawine@5: 		set: function( elem, value ) {
sawine@5: 			var style = elem.style,
sawine@5: 				currentStyle = elem.currentStyle,
sawine@5: 				opacity = jQuery.isNaN( value ) ? "" : "alpha(opacity=" + value * 100 + ")",
sawine@5: 				filter = currentStyle && currentStyle.filter || style.filter || "";
sawine@5: 
sawine@5: 			// IE has trouble with opacity if it does not have layout
sawine@5: 			// Force it by setting the zoom level
sawine@5: 			style.zoom = 1;
sawine@5: 
sawine@5: 			// if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
sawine@5: 			if ( value >= 1 && jQuery.trim( filter.replace( ralpha, "" ) ) === "" ) {
sawine@5: 
sawine@5: 				// Setting style.filter to null, "" & " " still leave "filter:" in the cssText
sawine@5: 				// if "filter:" is present at all, clearType is disabled, we want to avoid this
sawine@5: 				// style.removeAttribute is IE Only, but so apparently is this code path...
sawine@5: 				style.removeAttribute( "filter" );
sawine@5: 
sawine@5: 				// if there there is no filter style applied in a css rule, we are done
sawine@5: 				if ( currentStyle && !currentStyle.filter ) {
sawine@5: 					return;
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			// otherwise, set new filter values
sawine@5: 			style.filter = ralpha.test( filter ) ?
sawine@5: 				filter.replace( ralpha, opacity ) :
sawine@5: 				filter + " " + opacity;
sawine@5: 		}
sawine@5: 	};
sawine@5: }
sawine@5: 
sawine@5: jQuery(function() {
sawine@5: 	// This hook cannot be added until DOM ready because the support test
sawine@5: 	// for it is not run until after DOM ready
sawine@5: 	if ( !jQuery.support.reliableMarginRight ) {
sawine@5: 		jQuery.cssHooks.marginRight = {
sawine@5: 			get: function( elem, computed ) {
sawine@5: 				// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
sawine@5: 				// Work around by temporarily setting element display to inline-block
sawine@5: 				var ret;
sawine@5: 				jQuery.swap( elem, { "display": "inline-block" }, function() {
sawine@5: 					if ( computed ) {
sawine@5: 						ret = curCSS( elem, "margin-right", "marginRight" );
sawine@5: 					} else {
sawine@5: 						ret = elem.style.marginRight;
sawine@5: 					}
sawine@5: 				});
sawine@5: 				return ret;
sawine@5: 			}
sawine@5: 		};
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: if ( document.defaultView && document.defaultView.getComputedStyle ) {
sawine@5: 	getComputedStyle = function( elem, name ) {
sawine@5: 		var ret, defaultView, computedStyle;
sawine@5: 
sawine@5: 		name = name.replace( rupper, "-$1" ).toLowerCase();
sawine@5: 
sawine@5: 		if ( !(defaultView = elem.ownerDocument.defaultView) ) {
sawine@5: 			return undefined;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
sawine@5: 			ret = computedStyle.getPropertyValue( name );
sawine@5: 			if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
sawine@5: 				ret = jQuery.style( elem, name );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return ret;
sawine@5: 	};
sawine@5: }
sawine@5: 
sawine@5: if ( document.documentElement.currentStyle ) {
sawine@5: 	currentStyle = function( elem, name ) {
sawine@5: 		var left,
sawine@5: 			ret = elem.currentStyle && elem.currentStyle[ name ],
sawine@5: 			rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ],
sawine@5: 			style = elem.style;
sawine@5: 
sawine@5: 		// From the awesome hack by Dean Edwards
sawine@5: 		// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
sawine@5: 
sawine@5: 		// If we're not dealing with a regular pixel number
sawine@5: 		// but a number that has a weird ending, we need to convert it to pixels
sawine@5: 		if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
sawine@5: 			// Remember the original values
sawine@5: 			left = style.left;
sawine@5: 
sawine@5: 			// Put in the new values to get a computed value out
sawine@5: 			if ( rsLeft ) {
sawine@5: 				elem.runtimeStyle.left = elem.currentStyle.left;
sawine@5: 			}
sawine@5: 			style.left = name === "fontSize" ? "1em" : (ret || 0);
sawine@5: 			ret = style.pixelLeft + "px";
sawine@5: 
sawine@5: 			// Revert the changed values
sawine@5: 			style.left = left;
sawine@5: 			if ( rsLeft ) {
sawine@5: 				elem.runtimeStyle.left = rsLeft;
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return ret === "" ? "auto" : ret;
sawine@5: 	};
sawine@5: }
sawine@5: 
sawine@5: curCSS = getComputedStyle || currentStyle;
sawine@5: 
sawine@5: function getWH( elem, name, extra ) {
sawine@5: 
sawine@5: 	// Start with offset property
sawine@5: 	var val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
sawine@5: 		which = name === "width" ? cssWidth : cssHeight;
sawine@5: 
sawine@5: 	if ( val > 0 ) {
sawine@5: 		if ( extra !== "border" ) {
sawine@5: 			jQuery.each( which, function() {
sawine@5: 				if ( !extra ) {
sawine@5: 					val -= parseFloat( jQuery.css( elem, "padding" + this ) ) || 0;
sawine@5: 				}
sawine@5: 				if ( extra === "margin" ) {
sawine@5: 					val += parseFloat( jQuery.css( elem, extra + this ) ) || 0;
sawine@5: 				} else {
sawine@5: 					val -= parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) || 0;
sawine@5: 				}
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		return val + "px";
sawine@5: 	}
sawine@5: 
sawine@5: 	// Fall back to computed then uncomputed css if necessary
sawine@5: 	val = curCSS( elem, name, name );
sawine@5: 	if ( val < 0 || val == null ) {
sawine@5: 		val = elem.style[ name ] || 0;
sawine@5: 	}
sawine@5: 	// Normalize "", auto, and prepare for extra
sawine@5: 	val = parseFloat( val ) || 0;
sawine@5: 
sawine@5: 	// Add padding, border, margin
sawine@5: 	if ( extra ) {
sawine@5: 		jQuery.each( which, function() {
sawine@5: 			val += parseFloat( jQuery.css( elem, "padding" + this ) ) || 0;
sawine@5: 			if ( extra !== "padding" ) {
sawine@5: 				val += parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) || 0;
sawine@5: 			}
sawine@5: 			if ( extra === "margin" ) {
sawine@5: 				val += parseFloat( jQuery.css( elem, extra + this ) ) || 0;
sawine@5: 			}
sawine@5: 		});
sawine@5: 	}
sawine@5: 
sawine@5: 	return val + "px";
sawine@5: }
sawine@5: 
sawine@5: if ( jQuery.expr && jQuery.expr.filters ) {
sawine@5: 	jQuery.expr.filters.hidden = function( elem ) {
sawine@5: 		var width = elem.offsetWidth,
sawine@5: 			height = elem.offsetHeight;
sawine@5: 
sawine@5: 		return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
sawine@5: 	};
sawine@5: 
sawine@5: 	jQuery.expr.filters.visible = function( elem ) {
sawine@5: 		return !jQuery.expr.filters.hidden( elem );
sawine@5: 	};
sawine@5: }
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: var r20 = /%20/g,
sawine@5: 	rbracket = /\[\]$/,
sawine@5: 	rCRLF = /\r?\n/g,
sawine@5: 	rhash = /#.*$/,
sawine@5: 	rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
sawine@5: 	rinput = /^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
sawine@5: 	// #7653, #8125, #8152: local protocol detection
sawine@5: 	rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,
sawine@5: 	rnoContent = /^(?:GET|HEAD)$/,
sawine@5: 	rprotocol = /^\/\//,
sawine@5: 	rquery = /\?/,
sawine@5: 	rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
sawine@5: 	rselectTextarea = /^(?:select|textarea)/i,
sawine@5: 	rspacesAjax = /\s+/,
sawine@5: 	rts = /([?&])_=[^&]*/,
sawine@5: 	rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
sawine@5: 
sawine@5: 	// Keep a copy of the old load method
sawine@5: 	_load = jQuery.fn.load,
sawine@5: 
sawine@5: 	/* Prefilters
sawine@5: 	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
sawine@5: 	 * 2) These are called:
sawine@5: 	 *    - BEFORE asking for a transport
sawine@5: 	 *    - AFTER param serialization (s.data is a string if s.processData is true)
sawine@5: 	 * 3) key is the dataType
sawine@5: 	 * 4) the catchall symbol "*" can be used
sawine@5: 	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
sawine@5: 	 */
sawine@5: 	prefilters = {},
sawine@5: 
sawine@5: 	/* Transports bindings
sawine@5: 	 * 1) key is the dataType
sawine@5: 	 * 2) the catchall symbol "*" can be used
sawine@5: 	 * 3) selection will start with transport dataType and THEN go to "*" if needed
sawine@5: 	 */
sawine@5: 	transports = {},
sawine@5: 
sawine@5: 	// Document location
sawine@5: 	ajaxLocation,
sawine@5: 
sawine@5: 	// Document location segments
sawine@5: 	ajaxLocParts,
sawine@5: 	
sawine@5: 	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
sawine@5: 	allTypes = ["*/"] + ["*"];
sawine@5: 
sawine@5: // #8138, IE may throw an exception when accessing
sawine@5: // a field from window.location if document.domain has been set
sawine@5: try {
sawine@5: 	ajaxLocation = location.href;
sawine@5: } catch( e ) {
sawine@5: 	// Use the href attribute of an A element
sawine@5: 	// since IE will modify it given document.location
sawine@5: 	ajaxLocation = document.createElement( "a" );
sawine@5: 	ajaxLocation.href = "";
sawine@5: 	ajaxLocation = ajaxLocation.href;
sawine@5: }
sawine@5: 
sawine@5: // Segment location into parts
sawine@5: ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
sawine@5: 
sawine@5: // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
sawine@5: function addToPrefiltersOrTransports( structure ) {
sawine@5: 
sawine@5: 	// dataTypeExpression is optional and defaults to "*"
sawine@5: 	return function( dataTypeExpression, func ) {
sawine@5: 
sawine@5: 		if ( typeof dataTypeExpression !== "string" ) {
sawine@5: 			func = dataTypeExpression;
sawine@5: 			dataTypeExpression = "*";
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( jQuery.isFunction( func ) ) {
sawine@5: 			var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
sawine@5: 				i = 0,
sawine@5: 				length = dataTypes.length,
sawine@5: 				dataType,
sawine@5: 				list,
sawine@5: 				placeBefore;
sawine@5: 
sawine@5: 			// For each dataType in the dataTypeExpression
sawine@5: 			for(; i < length; i++ ) {
sawine@5: 				dataType = dataTypes[ i ];
sawine@5: 				// We control if we're asked to add before
sawine@5: 				// any existing element
sawine@5: 				placeBefore = /^\+/.test( dataType );
sawine@5: 				if ( placeBefore ) {
sawine@5: 					dataType = dataType.substr( 1 ) || "*";
sawine@5: 				}
sawine@5: 				list = structure[ dataType ] = structure[ dataType ] || [];
sawine@5: 				// then we add to the structure accordingly
sawine@5: 				list[ placeBefore ? "unshift" : "push" ]( func );
sawine@5: 			}
sawine@5: 		}
sawine@5: 	};
sawine@5: }
sawine@5: 
sawine@5: // Base inspection function for prefilters and transports
sawine@5: function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
sawine@5: 		dataType /* internal */, inspected /* internal */ ) {
sawine@5: 
sawine@5: 	dataType = dataType || options.dataTypes[ 0 ];
sawine@5: 	inspected = inspected || {};
sawine@5: 
sawine@5: 	inspected[ dataType ] = true;
sawine@5: 
sawine@5: 	var list = structure[ dataType ],
sawine@5: 		i = 0,
sawine@5: 		length = list ? list.length : 0,
sawine@5: 		executeOnly = ( structure === prefilters ),
sawine@5: 		selection;
sawine@5: 
sawine@5: 	for(; i < length && ( executeOnly || !selection ); i++ ) {
sawine@5: 		selection = list[ i ]( options, originalOptions, jqXHR );
sawine@5: 		// If we got redirected to another dataType
sawine@5: 		// we try there if executing only and not done already
sawine@5: 		if ( typeof selection === "string" ) {
sawine@5: 			if ( !executeOnly || inspected[ selection ] ) {
sawine@5: 				selection = undefined;
sawine@5: 			} else {
sawine@5: 				options.dataTypes.unshift( selection );
sawine@5: 				selection = inspectPrefiltersOrTransports(
sawine@5: 						structure, options, originalOptions, jqXHR, selection, inspected );
sawine@5: 			}
sawine@5: 		}
sawine@5: 	}
sawine@5: 	// If we're only executing or nothing was selected
sawine@5: 	// we try the catchall dataType if not done already
sawine@5: 	if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
sawine@5: 		selection = inspectPrefiltersOrTransports(
sawine@5: 				structure, options, originalOptions, jqXHR, "*", inspected );
sawine@5: 	}
sawine@5: 	// unnecessary when only executing (prefilters)
sawine@5: 	// but it'll be ignored by the caller in that case
sawine@5: 	return selection;
sawine@5: }
sawine@5: 
sawine@5: // A special extend for ajax options
sawine@5: // that takes "flat" options (not to be deep extended)
sawine@5: // Fixes #9887
sawine@5: function ajaxExtend( target, src ) {
sawine@5: 	var key, deep,
sawine@5: 		flatOptions = jQuery.ajaxSettings.flatOptions || {};
sawine@5: 	for( key in src ) {
sawine@5: 		if ( src[ key ] !== undefined ) {
sawine@5: 			( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
sawine@5: 		}
sawine@5: 	}
sawine@5: 	if ( deep ) {
sawine@5: 		jQuery.extend( true, target, deep );
sawine@5: 	}
sawine@5: }
sawine@5: 
sawine@5: jQuery.fn.extend({
sawine@5: 	load: function( url, params, callback ) {
sawine@5: 		if ( typeof url !== "string" && _load ) {
sawine@5: 			return _load.apply( this, arguments );
sawine@5: 
sawine@5: 		// Don't do a request if no elements are being requested
sawine@5: 		} else if ( !this.length ) {
sawine@5: 			return this;
sawine@5: 		}
sawine@5: 
sawine@5: 		var off = url.indexOf( " " );
sawine@5: 		if ( off >= 0 ) {
sawine@5: 			var selector = url.slice( off, url.length );
sawine@5: 			url = url.slice( 0, off );
sawine@5: 		}
sawine@5: 
sawine@5: 		// Default to a GET request
sawine@5: 		var type = "GET";
sawine@5: 
sawine@5: 		// If the second parameter was provided
sawine@5: 		if ( params ) {
sawine@5: 			// If it's a function
sawine@5: 			if ( jQuery.isFunction( params ) ) {
sawine@5: 				// We assume that it's the callback
sawine@5: 				callback = params;
sawine@5: 				params = undefined;
sawine@5: 
sawine@5: 			// Otherwise, build a param string
sawine@5: 			} else if ( typeof params === "object" ) {
sawine@5: 				params = jQuery.param( params, jQuery.ajaxSettings.traditional );
sawine@5: 				type = "POST";
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		var self = this;
sawine@5: 
sawine@5: 		// Request the remote document
sawine@5: 		jQuery.ajax({
sawine@5: 			url: url,
sawine@5: 			type: type,
sawine@5: 			dataType: "html",
sawine@5: 			data: params,
sawine@5: 			// Complete callback (responseText is used internally)
sawine@5: 			complete: function( jqXHR, status, responseText ) {
sawine@5: 				// Store the response as specified by the jqXHR object
sawine@5: 				responseText = jqXHR.responseText;
sawine@5: 				// If successful, inject the HTML into all the matched elements
sawine@5: 				if ( jqXHR.isResolved() ) {
sawine@5: 					// #4825: Get the actual response in case
sawine@5: 					// a dataFilter is present in ajaxSettings
sawine@5: 					jqXHR.done(function( r ) {
sawine@5: 						responseText = r;
sawine@5: 					});
sawine@5: 					// See if a selector was specified
sawine@5: 					self.html( selector ?
sawine@5: 						// Create a dummy div to hold the results
sawine@5: 						jQuery("<div>")
sawine@5: 							// inject the contents of the document in, removing the scripts
sawine@5: 							// to avoid any 'Permission Denied' errors in IE
sawine@5: 							.append(responseText.replace(rscript, ""))
sawine@5: 
sawine@5: 							// Locate the specified elements
sawine@5: 							.find(selector) :
sawine@5: 
sawine@5: 						// If not, just inject the full result
sawine@5: 						responseText );
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( callback ) {
sawine@5: 					self.each( callback, [ responseText, status, jqXHR ] );
sawine@5: 				}
sawine@5: 			}
sawine@5: 		});
sawine@5: 
sawine@5: 		return this;
sawine@5: 	},
sawine@5: 
sawine@5: 	serialize: function() {
sawine@5: 		return jQuery.param( this.serializeArray() );
sawine@5: 	},
sawine@5: 
sawine@5: 	serializeArray: function() {
sawine@5: 		return this.map(function(){
sawine@5: 			return this.elements ? jQuery.makeArray( this.elements ) : this;
sawine@5: 		})
sawine@5: 		.filter(function(){
sawine@5: 			return this.name && !this.disabled &&
sawine@5: 				( this.checked || rselectTextarea.test( this.nodeName ) ||
sawine@5: 					rinput.test( this.type ) );
sawine@5: 		})
sawine@5: 		.map(function( i, elem ){
sawine@5: 			var val = jQuery( this ).val();
sawine@5: 
sawine@5: 			return val == null ?
sawine@5: 				null :
sawine@5: 				jQuery.isArray( val ) ?
sawine@5: 					jQuery.map( val, function( val, i ){
sawine@5: 						return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
sawine@5: 					}) :
sawine@5: 					{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
sawine@5: 		}).get();
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: // Attach a bunch of functions for handling common AJAX events
sawine@5: jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
sawine@5: 	jQuery.fn[ o ] = function( f ){
sawine@5: 		return this.bind( o, f );
sawine@5: 	};
sawine@5: });
sawine@5: 
sawine@5: jQuery.each( [ "get", "post" ], function( i, method ) {
sawine@5: 	jQuery[ method ] = function( url, data, callback, type ) {
sawine@5: 		// shift arguments if data argument was omitted
sawine@5: 		if ( jQuery.isFunction( data ) ) {
sawine@5: 			type = type || callback;
sawine@5: 			callback = data;
sawine@5: 			data = undefined;
sawine@5: 		}
sawine@5: 
sawine@5: 		return jQuery.ajax({
sawine@5: 			type: method,
sawine@5: 			url: url,
sawine@5: 			data: data,
sawine@5: 			success: callback,
sawine@5: 			dataType: type
sawine@5: 		});
sawine@5: 	};
sawine@5: });
sawine@5: 
sawine@5: jQuery.extend({
sawine@5: 
sawine@5: 	getScript: function( url, callback ) {
sawine@5: 		return jQuery.get( url, undefined, callback, "script" );
sawine@5: 	},
sawine@5: 
sawine@5: 	getJSON: function( url, data, callback ) {
sawine@5: 		return jQuery.get( url, data, callback, "json" );
sawine@5: 	},
sawine@5: 
sawine@5: 	// Creates a full fledged settings object into target
sawine@5: 	// with both ajaxSettings and settings fields.
sawine@5: 	// If target is omitted, writes into ajaxSettings.
sawine@5: 	ajaxSetup: function( target, settings ) {
sawine@5: 		if ( settings ) {
sawine@5: 			// Building a settings object
sawine@5: 			ajaxExtend( target, jQuery.ajaxSettings );
sawine@5: 		} else {
sawine@5: 			// Extending ajaxSettings
sawine@5: 			settings = target;
sawine@5: 			target = jQuery.ajaxSettings;
sawine@5: 		}
sawine@5: 		ajaxExtend( target, settings );
sawine@5: 		return target;
sawine@5: 	},
sawine@5: 
sawine@5: 	ajaxSettings: {
sawine@5: 		url: ajaxLocation,
sawine@5: 		isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
sawine@5: 		global: true,
sawine@5: 		type: "GET",
sawine@5: 		contentType: "application/x-www-form-urlencoded",
sawine@5: 		processData: true,
sawine@5: 		async: true,
sawine@5: 		/*
sawine@5: 		timeout: 0,
sawine@5: 		data: null,
sawine@5: 		dataType: null,
sawine@5: 		username: null,
sawine@5: 		password: null,
sawine@5: 		cache: null,
sawine@5: 		traditional: false,
sawine@5: 		headers: {},
sawine@5: 		*/
sawine@5: 
sawine@5: 		accepts: {
sawine@5: 			xml: "application/xml, text/xml",
sawine@5: 			html: "text/html",
sawine@5: 			text: "text/plain",
sawine@5: 			json: "application/json, text/javascript",
sawine@5: 			"*": allTypes
sawine@5: 		},
sawine@5: 
sawine@5: 		contents: {
sawine@5: 			xml: /xml/,
sawine@5: 			html: /html/,
sawine@5: 			json: /json/
sawine@5: 		},
sawine@5: 
sawine@5: 		responseFields: {
sawine@5: 			xml: "responseXML",
sawine@5: 			text: "responseText"
sawine@5: 		},
sawine@5: 
sawine@5: 		// List of data converters
sawine@5: 		// 1) key format is "source_type destination_type" (a single space in-between)
sawine@5: 		// 2) the catchall symbol "*" can be used for source_type
sawine@5: 		converters: {
sawine@5: 
sawine@5: 			// Convert anything to text
sawine@5: 			"* text": window.String,
sawine@5: 
sawine@5: 			// Text to html (true = no transformation)
sawine@5: 			"text html": true,
sawine@5: 
sawine@5: 			// Evaluate text as a json expression
sawine@5: 			"text json": jQuery.parseJSON,
sawine@5: 
sawine@5: 			// Parse text as xml
sawine@5: 			"text xml": jQuery.parseXML
sawine@5: 		},
sawine@5: 
sawine@5: 		// For options that shouldn't be deep extended:
sawine@5: 		// you can add your own custom options here if
sawine@5: 		// and when you create one that shouldn't be
sawine@5: 		// deep extended (see ajaxExtend)
sawine@5: 		flatOptions: {
sawine@5: 			context: true,
sawine@5: 			url: true
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
sawine@5: 	ajaxTransport: addToPrefiltersOrTransports( transports ),
sawine@5: 
sawine@5: 	// Main method
sawine@5: 	ajax: function( url, options ) {
sawine@5: 
sawine@5: 		// If url is an object, simulate pre-1.5 signature
sawine@5: 		if ( typeof url === "object" ) {
sawine@5: 			options = url;
sawine@5: 			url = undefined;
sawine@5: 		}
sawine@5: 
sawine@5: 		// Force options to be an object
sawine@5: 		options = options || {};
sawine@5: 
sawine@5: 		var // Create the final options object
sawine@5: 			s = jQuery.ajaxSetup( {}, options ),
sawine@5: 			// Callbacks context
sawine@5: 			callbackContext = s.context || s,
sawine@5: 			// Context for global events
sawine@5: 			// It's the callbackContext if one was provided in the options
sawine@5: 			// and if it's a DOM node or a jQuery collection
sawine@5: 			globalEventContext = callbackContext !== s &&
sawine@5: 				( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
sawine@5: 						jQuery( callbackContext ) : jQuery.event,
sawine@5: 			// Deferreds
sawine@5: 			deferred = jQuery.Deferred(),
sawine@5: 			completeDeferred = jQuery._Deferred(),
sawine@5: 			// Status-dependent callbacks
sawine@5: 			statusCode = s.statusCode || {},
sawine@5: 			// ifModified key
sawine@5: 			ifModifiedKey,
sawine@5: 			// Headers (they are sent all at once)
sawine@5: 			requestHeaders = {},
sawine@5: 			requestHeadersNames = {},
sawine@5: 			// Response headers
sawine@5: 			responseHeadersString,
sawine@5: 			responseHeaders,
sawine@5: 			// transport
sawine@5: 			transport,
sawine@5: 			// timeout handle
sawine@5: 			timeoutTimer,
sawine@5: 			// Cross-domain detection vars
sawine@5: 			parts,
sawine@5: 			// The jqXHR state
sawine@5: 			state = 0,
sawine@5: 			// To know if global events are to be dispatched
sawine@5: 			fireGlobals,
sawine@5: 			// Loop variable
sawine@5: 			i,
sawine@5: 			// Fake xhr
sawine@5: 			jqXHR = {
sawine@5: 
sawine@5: 				readyState: 0,
sawine@5: 
sawine@5: 				// Caches the header
sawine@5: 				setRequestHeader: function( name, value ) {
sawine@5: 					if ( !state ) {
sawine@5: 						var lname = name.toLowerCase();
sawine@5: 						name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
sawine@5: 						requestHeaders[ name ] = value;
sawine@5: 					}
sawine@5: 					return this;
sawine@5: 				},
sawine@5: 
sawine@5: 				// Raw string
sawine@5: 				getAllResponseHeaders: function() {
sawine@5: 					return state === 2 ? responseHeadersString : null;
sawine@5: 				},
sawine@5: 
sawine@5: 				// Builds headers hashtable if needed
sawine@5: 				getResponseHeader: function( key ) {
sawine@5: 					var match;
sawine@5: 					if ( state === 2 ) {
sawine@5: 						if ( !responseHeaders ) {
sawine@5: 							responseHeaders = {};
sawine@5: 							while( ( match = rheaders.exec( responseHeadersString ) ) ) {
sawine@5: 								responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
sawine@5: 							}
sawine@5: 						}
sawine@5: 						match = responseHeaders[ key.toLowerCase() ];
sawine@5: 					}
sawine@5: 					return match === undefined ? null : match;
sawine@5: 				},
sawine@5: 
sawine@5: 				// Overrides response content-type header
sawine@5: 				overrideMimeType: function( type ) {
sawine@5: 					if ( !state ) {
sawine@5: 						s.mimeType = type;
sawine@5: 					}
sawine@5: 					return this;
sawine@5: 				},
sawine@5: 
sawine@5: 				// Cancel the request
sawine@5: 				abort: function( statusText ) {
sawine@5: 					statusText = statusText || "abort";
sawine@5: 					if ( transport ) {
sawine@5: 						transport.abort( statusText );
sawine@5: 					}
sawine@5: 					done( 0, statusText );
sawine@5: 					return this;
sawine@5: 				}
sawine@5: 			};
sawine@5: 
sawine@5: 		// Callback for when everything is done
sawine@5: 		// It is defined here because jslint complains if it is declared
sawine@5: 		// at the end of the function (which would be more logical and readable)
sawine@5: 		function done( status, nativeStatusText, responses, headers ) {
sawine@5: 
sawine@5: 			// Called once
sawine@5: 			if ( state === 2 ) {
sawine@5: 				return;
sawine@5: 			}
sawine@5: 
sawine@5: 			// State is "done" now
sawine@5: 			state = 2;
sawine@5: 
sawine@5: 			// Clear timeout if it exists
sawine@5: 			if ( timeoutTimer ) {
sawine@5: 				clearTimeout( timeoutTimer );
sawine@5: 			}
sawine@5: 
sawine@5: 			// Dereference transport for early garbage collection
sawine@5: 			// (no matter how long the jqXHR object will be used)
sawine@5: 			transport = undefined;
sawine@5: 
sawine@5: 			// Cache response headers
sawine@5: 			responseHeadersString = headers || "";
sawine@5: 
sawine@5: 			// Set readyState
sawine@5: 			jqXHR.readyState = status > 0 ? 4 : 0;
sawine@5: 
sawine@5: 			var isSuccess,
sawine@5: 				success,
sawine@5: 				error,
sawine@5: 				statusText = nativeStatusText,
sawine@5: 				response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
sawine@5: 				lastModified,
sawine@5: 				etag;
sawine@5: 
sawine@5: 			// If successful, handle type chaining
sawine@5: 			if ( status >= 200 && status < 300 || status === 304 ) {
sawine@5: 
sawine@5: 				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
sawine@5: 				if ( s.ifModified ) {
sawine@5: 
sawine@5: 					if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
sawine@5: 						jQuery.lastModified[ ifModifiedKey ] = lastModified;
sawine@5: 					}
sawine@5: 					if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
sawine@5: 						jQuery.etag[ ifModifiedKey ] = etag;
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				// If not modified
sawine@5: 				if ( status === 304 ) {
sawine@5: 
sawine@5: 					statusText = "notmodified";
sawine@5: 					isSuccess = true;
sawine@5: 
sawine@5: 				// If we have data
sawine@5: 				} else {
sawine@5: 
sawine@5: 					try {
sawine@5: 						success = ajaxConvert( s, response );
sawine@5: 						statusText = "success";
sawine@5: 						isSuccess = true;
sawine@5: 					} catch(e) {
sawine@5: 						// We have a parsererror
sawine@5: 						statusText = "parsererror";
sawine@5: 						error = e;
sawine@5: 					}
sawine@5: 				}
sawine@5: 			} else {
sawine@5: 				// We extract error from statusText
sawine@5: 				// then normalize statusText and status for non-aborts
sawine@5: 				error = statusText;
sawine@5: 				if( !statusText || status ) {
sawine@5: 					statusText = "error";
sawine@5: 					if ( status < 0 ) {
sawine@5: 						status = 0;
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			// Set data for the fake xhr object
sawine@5: 			jqXHR.status = status;
sawine@5: 			jqXHR.statusText = "" + ( nativeStatusText || statusText );
sawine@5: 
sawine@5: 			// Success/Error
sawine@5: 			if ( isSuccess ) {
sawine@5: 				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
sawine@5: 			} else {
sawine@5: 				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
sawine@5: 			}
sawine@5: 
sawine@5: 			// Status-dependent callbacks
sawine@5: 			jqXHR.statusCode( statusCode );
sawine@5: 			statusCode = undefined;
sawine@5: 
sawine@5: 			if ( fireGlobals ) {
sawine@5: 				globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
sawine@5: 						[ jqXHR, s, isSuccess ? success : error ] );
sawine@5: 			}
sawine@5: 
sawine@5: 			// Complete
sawine@5: 			completeDeferred.resolveWith( callbackContext, [ jqXHR, statusText ] );
sawine@5: 
sawine@5: 			if ( fireGlobals ) {
sawine@5: 				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
sawine@5: 				// Handle the global AJAX counter
sawine@5: 				if ( !( --jQuery.active ) ) {
sawine@5: 					jQuery.event.trigger( "ajaxStop" );
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		// Attach deferreds
sawine@5: 		deferred.promise( jqXHR );
sawine@5: 		jqXHR.success = jqXHR.done;
sawine@5: 		jqXHR.error = jqXHR.fail;
sawine@5: 		jqXHR.complete = completeDeferred.done;
sawine@5: 
sawine@5: 		// Status-dependent callbacks
sawine@5: 		jqXHR.statusCode = function( map ) {
sawine@5: 			if ( map ) {
sawine@5: 				var tmp;
sawine@5: 				if ( state < 2 ) {
sawine@5: 					for( tmp in map ) {
sawine@5: 						statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
sawine@5: 					}
sawine@5: 				} else {
sawine@5: 					tmp = map[ jqXHR.status ];
sawine@5: 					jqXHR.then( tmp, tmp );
sawine@5: 				}
sawine@5: 			}
sawine@5: 			return this;
sawine@5: 		};
sawine@5: 
sawine@5: 		// Remove hash character (#7531: and string promotion)
sawine@5: 		// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
sawine@5: 		// We also use the url parameter if available
sawine@5: 		s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
sawine@5: 
sawine@5: 		// Extract dataTypes list
sawine@5: 		s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );
sawine@5: 
sawine@5: 		// Determine if a cross-domain request is in order
sawine@5: 		if ( s.crossDomain == null ) {
sawine@5: 			parts = rurl.exec( s.url.toLowerCase() );
sawine@5: 			s.crossDomain = !!( parts &&
sawine@5: 				( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
sawine@5: 					( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
sawine@5: 						( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
sawine@5: 			);
sawine@5: 		}
sawine@5: 
sawine@5: 		// Convert data if not already a string
sawine@5: 		if ( s.data && s.processData && typeof s.data !== "string" ) {
sawine@5: 			s.data = jQuery.param( s.data, s.traditional );
sawine@5: 		}
sawine@5: 
sawine@5: 		// Apply prefilters
sawine@5: 		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
sawine@5: 
sawine@5: 		// If request was aborted inside a prefiler, stop there
sawine@5: 		if ( state === 2 ) {
sawine@5: 			return false;
sawine@5: 		}
sawine@5: 
sawine@5: 		// We can fire global events as of now if asked to
sawine@5: 		fireGlobals = s.global;
sawine@5: 
sawine@5: 		// Uppercase the type
sawine@5: 		s.type = s.type.toUpperCase();
sawine@5: 
sawine@5: 		// Determine if request has content
sawine@5: 		s.hasContent = !rnoContent.test( s.type );
sawine@5: 
sawine@5: 		// Watch for a new set of requests
sawine@5: 		if ( fireGlobals && jQuery.active++ === 0 ) {
sawine@5: 			jQuery.event.trigger( "ajaxStart" );
sawine@5: 		}
sawine@5: 
sawine@5: 		// More options handling for requests with no content
sawine@5: 		if ( !s.hasContent ) {
sawine@5: 
sawine@5: 			// If data is available, append data to url
sawine@5: 			if ( s.data ) {
sawine@5: 				s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
sawine@5: 				// #9682: remove data so that it's not used in an eventual retry
sawine@5: 				delete s.data;
sawine@5: 			}
sawine@5: 
sawine@5: 			// Get ifModifiedKey before adding the anti-cache parameter
sawine@5: 			ifModifiedKey = s.url;
sawine@5: 
sawine@5: 			// Add anti-cache in url if needed
sawine@5: 			if ( s.cache === false ) {
sawine@5: 
sawine@5: 				var ts = jQuery.now(),
sawine@5: 					// try replacing _= if it is there
sawine@5: 					ret = s.url.replace( rts, "$1_=" + ts );
sawine@5: 
sawine@5: 				// if nothing was replaced, add timestamp to the end
sawine@5: 				s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		// Set the correct header, if data is being sent
sawine@5: 		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
sawine@5: 			jqXHR.setRequestHeader( "Content-Type", s.contentType );
sawine@5: 		}
sawine@5: 
sawine@5: 		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
sawine@5: 		if ( s.ifModified ) {
sawine@5: 			ifModifiedKey = ifModifiedKey || s.url;
sawine@5: 			if ( jQuery.lastModified[ ifModifiedKey ] ) {
sawine@5: 				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
sawine@5: 			}
sawine@5: 			if ( jQuery.etag[ ifModifiedKey ] ) {
sawine@5: 				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		// Set the Accepts header for the server, depending on the dataType
sawine@5: 		jqXHR.setRequestHeader(
sawine@5: 			"Accept",
sawine@5: 			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
sawine@5: 				s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
sawine@5: 				s.accepts[ "*" ]
sawine@5: 		);
sawine@5: 
sawine@5: 		// Check for headers option
sawine@5: 		for ( i in s.headers ) {
sawine@5: 			jqXHR.setRequestHeader( i, s.headers[ i ] );
sawine@5: 		}
sawine@5: 
sawine@5: 		// Allow custom headers/mimetypes and early abort
sawine@5: 		if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
sawine@5: 				// Abort if not done already
sawine@5: 				jqXHR.abort();
sawine@5: 				return false;
sawine@5: 
sawine@5: 		}
sawine@5: 
sawine@5: 		// Install callbacks on deferreds
sawine@5: 		for ( i in { success: 1, error: 1, complete: 1 } ) {
sawine@5: 			jqXHR[ i ]( s[ i ] );
sawine@5: 		}
sawine@5: 
sawine@5: 		// Get transport
sawine@5: 		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
sawine@5: 
sawine@5: 		// If no transport, we auto-abort
sawine@5: 		if ( !transport ) {
sawine@5: 			done( -1, "No Transport" );
sawine@5: 		} else {
sawine@5: 			jqXHR.readyState = 1;
sawine@5: 			// Send global event
sawine@5: 			if ( fireGlobals ) {
sawine@5: 				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
sawine@5: 			}
sawine@5: 			// Timeout
sawine@5: 			if ( s.async && s.timeout > 0 ) {
sawine@5: 				timeoutTimer = setTimeout( function(){
sawine@5: 					jqXHR.abort( "timeout" );
sawine@5: 				}, s.timeout );
sawine@5: 			}
sawine@5: 
sawine@5: 			try {
sawine@5: 				state = 1;
sawine@5: 				transport.send( requestHeaders, done );
sawine@5: 			} catch (e) {
sawine@5: 				// Propagate exception as error if not done
sawine@5: 				if ( state < 2 ) {
sawine@5: 					done( -1, e );
sawine@5: 				// Simply rethrow otherwise
sawine@5: 				} else {
sawine@5: 					jQuery.error( e );
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		return jqXHR;
sawine@5: 	},
sawine@5: 
sawine@5: 	// Serialize an array of form elements or a set of
sawine@5: 	// key/values into a query string
sawine@5: 	param: function( a, traditional ) {
sawine@5: 		var s = [],
sawine@5: 			add = function( key, value ) {
sawine@5: 				// If value is a function, invoke it and return its value
sawine@5: 				value = jQuery.isFunction( value ) ? value() : value;
sawine@5: 				s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
sawine@5: 			};
sawine@5: 
sawine@5: 		// Set traditional to true for jQuery <= 1.3.2 behavior.
sawine@5: 		if ( traditional === undefined ) {
sawine@5: 			traditional = jQuery.ajaxSettings.traditional;
sawine@5: 		}
sawine@5: 
sawine@5: 		// If an array was passed in, assume that it is an array of form elements.
sawine@5: 		if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
sawine@5: 			// Serialize the form elements
sawine@5: 			jQuery.each( a, function() {
sawine@5: 				add( this.name, this.value );
sawine@5: 			});
sawine@5: 
sawine@5: 		} else {
sawine@5: 			// If traditional, encode the "old" way (the way 1.3.2 or older
sawine@5: 			// did it), otherwise encode params recursively.
sawine@5: 			for ( var prefix in a ) {
sawine@5: 				buildParams( prefix, a[ prefix ], traditional, add );
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		// Return the resulting serialization
sawine@5: 		return s.join( "&" ).replace( r20, "+" );
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: function buildParams( prefix, obj, traditional, add ) {
sawine@5: 	if ( jQuery.isArray( obj ) ) {
sawine@5: 		// Serialize array item.
sawine@5: 		jQuery.each( obj, function( i, v ) {
sawine@5: 			if ( traditional || rbracket.test( prefix ) ) {
sawine@5: 				// Treat each array item as a scalar.
sawine@5: 				add( prefix, v );
sawine@5: 
sawine@5: 			} else {
sawine@5: 				// If array item is non-scalar (array or object), encode its
sawine@5: 				// numeric index to resolve deserialization ambiguity issues.
sawine@5: 				// Note that rack (as of 1.0.0) can't currently deserialize
sawine@5: 				// nested arrays properly, and attempting to do so may cause
sawine@5: 				// a server error. Possible fixes are to modify rack's
sawine@5: 				// deserialization algorithm or to provide an option or flag
sawine@5: 				// to force array serialization to be shallow.
sawine@5: 				buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
sawine@5: 			}
sawine@5: 		});
sawine@5: 
sawine@5: 	} else if ( !traditional && obj != null && typeof obj === "object" ) {
sawine@5: 		// Serialize object item.
sawine@5: 		for ( var name in obj ) {
sawine@5: 			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
sawine@5: 		}
sawine@5: 
sawine@5: 	} else {
sawine@5: 		// Serialize scalar item.
sawine@5: 		add( prefix, obj );
sawine@5: 	}
sawine@5: }
sawine@5: 
sawine@5: // This is still on the jQuery object... for now
sawine@5: // Want to move this to jQuery.ajax some day
sawine@5: jQuery.extend({
sawine@5: 
sawine@5: 	// Counter for holding the number of active queries
sawine@5: 	active: 0,
sawine@5: 
sawine@5: 	// Last-Modified header cache for next request
sawine@5: 	lastModified: {},
sawine@5: 	etag: {}
sawine@5: 
sawine@5: });
sawine@5: 
sawine@5: /* Handles responses to an ajax request:
sawine@5:  * - sets all responseXXX fields accordingly
sawine@5:  * - finds the right dataType (mediates between content-type and expected dataType)
sawine@5:  * - returns the corresponding response
sawine@5:  */
sawine@5: function ajaxHandleResponses( s, jqXHR, responses ) {
sawine@5: 
sawine@5: 	var contents = s.contents,
sawine@5: 		dataTypes = s.dataTypes,
sawine@5: 		responseFields = s.responseFields,
sawine@5: 		ct,
sawine@5: 		type,
sawine@5: 		finalDataType,
sawine@5: 		firstDataType;
sawine@5: 
sawine@5: 	// Fill responseXXX fields
sawine@5: 	for( type in responseFields ) {
sawine@5: 		if ( type in responses ) {
sawine@5: 			jqXHR[ responseFields[type] ] = responses[ type ];
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	// Remove auto dataType and get content-type in the process
sawine@5: 	while( dataTypes[ 0 ] === "*" ) {
sawine@5: 		dataTypes.shift();
sawine@5: 		if ( ct === undefined ) {
sawine@5: 			ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	// Check if we're dealing with a known content-type
sawine@5: 	if ( ct ) {
sawine@5: 		for ( type in contents ) {
sawine@5: 			if ( contents[ type ] && contents[ type ].test( ct ) ) {
sawine@5: 				dataTypes.unshift( type );
sawine@5: 				break;
sawine@5: 			}
sawine@5: 		}
sawine@5: 	}
sawine@5: 
sawine@5: 	// Check to see if we have a response for the expected dataType
sawine@5: 	if ( dataTypes[ 0 ] in responses ) {
sawine@5: 		finalDataType = dataTypes[ 0 ];
sawine@5: 	} else {
sawine@5: 		// Try convertible dataTypes
sawine@5: 		for ( type in responses ) {
sawine@5: 			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
sawine@5: 				finalDataType = type;
sawine@5: 				break;
sawine@5: 			}
sawine@5: 			if ( !firstDataType ) {
sawine@5: 				firstDataType = type;
sawine@5: 			}
sawine@5: 		}
sawine@5: 		// Or just use first one
sawine@5: 		finalDataType = finalDataType || firstDataType;
sawine@5: 	}
sawine@5: 
sawine@5: 	// If we found a dataType
sawine@5: 	// We add the dataType to the list if needed
sawine@5: 	// and return the corresponding response
sawine@5: 	if ( finalDataType ) {
sawine@5: 		if ( finalDataType !== dataTypes[ 0 ] ) {
sawine@5: 			dataTypes.unshift( finalDataType );
sawine@5: 		}
sawine@5: 		return responses[ finalDataType ];
sawine@5: 	}
sawine@5: }
sawine@5: 
sawine@5: // Chain conversions given the request and the original response
sawine@5: function ajaxConvert( s, response ) {
sawine@5: 
sawine@5: 	// Apply the dataFilter if provided
sawine@5: 	if ( s.dataFilter ) {
sawine@5: 		response = s.dataFilter( response, s.dataType );
sawine@5: 	}
sawine@5: 
sawine@5: 	var dataTypes = s.dataTypes,
sawine@5: 		converters = {},
sawine@5: 		i,
sawine@5: 		key,
sawine@5: 		length = dataTypes.length,
sawine@5: 		tmp,
sawine@5: 		// Current and previous dataTypes
sawine@5: 		current = dataTypes[ 0 ],
sawine@5: 		prev,
sawine@5: 		// Conversion expression
sawine@5: 		conversion,
sawine@5: 		// Conversion function
sawine@5: 		conv,
sawine@5: 		// Conversion functions (transitive conversion)
sawine@5: 		conv1,
sawine@5: 		conv2;
sawine@5: 
sawine@5: 	// For each dataType in the chain
sawine@5: 	for( i = 1; i < length; i++ ) {
sawine@5: 
sawine@5: 		// Create converters map
sawine@5: 		// with lowercased keys
sawine@5: 		if ( i === 1 ) {
sawine@5: 			for( key in s.converters ) {
sawine@5: 				if( typeof key === "string" ) {
sawine@5: 					converters[ key.toLowerCase() ] = s.converters[ key ];
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		// Get the dataTypes
sawine@5: 		prev = current;
sawine@5: 		current = dataTypes[ i ];
sawine@5: 
sawine@5: 		// If current is auto dataType, update it to prev
sawine@5: 		if( current === "*" ) {
sawine@5: 			current = prev;
sawine@5: 		// If no auto and dataTypes are actually different
sawine@5: 		} else if ( prev !== "*" && prev !== current ) {
sawine@5: 
sawine@5: 			// Get the converter
sawine@5: 			conversion = prev + " " + current;
sawine@5: 			conv = converters[ conversion ] || converters[ "* " + current ];
sawine@5: 
sawine@5: 			// If there is no direct converter, search transitively
sawine@5: 			if ( !conv ) {
sawine@5: 				conv2 = undefined;
sawine@5: 				for( conv1 in converters ) {
sawine@5: 					tmp = conv1.split( " " );
sawine@5: 					if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
sawine@5: 						conv2 = converters[ tmp[1] + " " + current ];
sawine@5: 						if ( conv2 ) {
sawine@5: 							conv1 = converters[ conv1 ];
sawine@5: 							if ( conv1 === true ) {
sawine@5: 								conv = conv2;
sawine@5: 							} else if ( conv2 === true ) {
sawine@5: 								conv = conv1;
sawine@5: 							}
sawine@5: 							break;
sawine@5: 						}
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 			// If we found no converter, dispatch an error
sawine@5: 			if ( !( conv || conv2 ) ) {
sawine@5: 				jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
sawine@5: 			}
sawine@5: 			// If found converter is not an equivalence
sawine@5: 			if ( conv !== true ) {
sawine@5: 				// Convert with 1 or 2 converters accordingly
sawine@5: 				response = conv ? conv( response ) : conv2( conv1(response) );
sawine@5: 			}
sawine@5: 		}
sawine@5: 	}
sawine@5: 	return response;
sawine@5: }
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: var jsc = jQuery.now(),
sawine@5: 	jsre = /(\=)\?(&|$)|\?\?/i;
sawine@5: 
sawine@5: // Default jsonp settings
sawine@5: jQuery.ajaxSetup({
sawine@5: 	jsonp: "callback",
sawine@5: 	jsonpCallback: function() {
sawine@5: 		return jQuery.expando + "_" + ( jsc++ );
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: // Detect, normalize options and install callbacks for jsonp requests
sawine@5: jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
sawine@5: 
sawine@5: 	var inspectData = s.contentType === "application/x-www-form-urlencoded" &&
sawine@5: 		( typeof s.data === "string" );
sawine@5: 
sawine@5: 	if ( s.dataTypes[ 0 ] === "jsonp" ||
sawine@5: 		s.jsonp !== false && ( jsre.test( s.url ) ||
sawine@5: 				inspectData && jsre.test( s.data ) ) ) {
sawine@5: 
sawine@5: 		var responseContainer,
sawine@5: 			jsonpCallback = s.jsonpCallback =
sawine@5: 				jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
sawine@5: 			previous = window[ jsonpCallback ],
sawine@5: 			url = s.url,
sawine@5: 			data = s.data,
sawine@5: 			replace = "$1" + jsonpCallback + "$2";
sawine@5: 
sawine@5: 		if ( s.jsonp !== false ) {
sawine@5: 			url = url.replace( jsre, replace );
sawine@5: 			if ( s.url === url ) {
sawine@5: 				if ( inspectData ) {
sawine@5: 					data = data.replace( jsre, replace );
sawine@5: 				}
sawine@5: 				if ( s.data === data ) {
sawine@5: 					// Add callback manually
sawine@5: 					url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
sawine@5: 				}
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		s.url = url;
sawine@5: 		s.data = data;
sawine@5: 
sawine@5: 		// Install callback
sawine@5: 		window[ jsonpCallback ] = function( response ) {
sawine@5: 			responseContainer = [ response ];
sawine@5: 		};
sawine@5: 
sawine@5: 		// Clean-up function
sawine@5: 		jqXHR.always(function() {
sawine@5: 			// Set callback back to previous value
sawine@5: 			window[ jsonpCallback ] = previous;
sawine@5: 			// Call if it was a function and we have a response
sawine@5: 			if ( responseContainer && jQuery.isFunction( previous ) ) {
sawine@5: 				window[ jsonpCallback ]( responseContainer[ 0 ] );
sawine@5: 			}
sawine@5: 		});
sawine@5: 
sawine@5: 		// Use data converter to retrieve json after script execution
sawine@5: 		s.converters["script json"] = function() {
sawine@5: 			if ( !responseContainer ) {
sawine@5: 				jQuery.error( jsonpCallback + " was not called" );
sawine@5: 			}
sawine@5: 			return responseContainer[ 0 ];
sawine@5: 		};
sawine@5: 
sawine@5: 		// force json dataType
sawine@5: 		s.dataTypes[ 0 ] = "json";
sawine@5: 
sawine@5: 		// Delegate to script
sawine@5: 		return "script";
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: // Install script dataType
sawine@5: jQuery.ajaxSetup({
sawine@5: 	accepts: {
sawine@5: 		script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
sawine@5: 	},
sawine@5: 	contents: {
sawine@5: 		script: /javascript|ecmascript/
sawine@5: 	},
sawine@5: 	converters: {
sawine@5: 		"text script": function( text ) {
sawine@5: 			jQuery.globalEval( text );
sawine@5: 			return text;
sawine@5: 		}
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: // Handle cache's special case and global
sawine@5: jQuery.ajaxPrefilter( "script", function( s ) {
sawine@5: 	if ( s.cache === undefined ) {
sawine@5: 		s.cache = false;
sawine@5: 	}
sawine@5: 	if ( s.crossDomain ) {
sawine@5: 		s.type = "GET";
sawine@5: 		s.global = false;
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: // Bind script tag hack transport
sawine@5: jQuery.ajaxTransport( "script", function(s) {
sawine@5: 
sawine@5: 	// This transport only deals with cross domain requests
sawine@5: 	if ( s.crossDomain ) {
sawine@5: 
sawine@5: 		var script,
sawine@5: 			head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
sawine@5: 
sawine@5: 		return {
sawine@5: 
sawine@5: 			send: function( _, callback ) {
sawine@5: 
sawine@5: 				script = document.createElement( "script" );
sawine@5: 
sawine@5: 				script.async = "async";
sawine@5: 
sawine@5: 				if ( s.scriptCharset ) {
sawine@5: 					script.charset = s.scriptCharset;
sawine@5: 				}
sawine@5: 
sawine@5: 				script.src = s.url;
sawine@5: 
sawine@5: 				// Attach handlers for all browsers
sawine@5: 				script.onload = script.onreadystatechange = function( _, isAbort ) {
sawine@5: 
sawine@5: 					if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
sawine@5: 
sawine@5: 						// Handle memory leak in IE
sawine@5: 						script.onload = script.onreadystatechange = null;
sawine@5: 
sawine@5: 						// Remove the script
sawine@5: 						if ( head && script.parentNode ) {
sawine@5: 							head.removeChild( script );
sawine@5: 						}
sawine@5: 
sawine@5: 						// Dereference the script
sawine@5: 						script = undefined;
sawine@5: 
sawine@5: 						// Callback if not abort
sawine@5: 						if ( !isAbort ) {
sawine@5: 							callback( 200, "success" );
sawine@5: 						}
sawine@5: 					}
sawine@5: 				};
sawine@5: 				// Use insertBefore instead of appendChild  to circumvent an IE6 bug.
sawine@5: 				// This arises when a base node is used (#2709 and #4378).
sawine@5: 				head.insertBefore( script, head.firstChild );
sawine@5: 			},
sawine@5: 
sawine@5: 			abort: function() {
sawine@5: 				if ( script ) {
sawine@5: 					script.onload( 0, 1 );
sawine@5: 				}
sawine@5: 			}
sawine@5: 		};
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: var // #5280: Internet Explorer will keep connections alive if we don't abort on unload
sawine@5: 	xhrOnUnloadAbort = window.ActiveXObject ? function() {
sawine@5: 		// Abort all pending requests
sawine@5: 		for ( var key in xhrCallbacks ) {
sawine@5: 			xhrCallbacks[ key ]( 0, 1 );
sawine@5: 		}
sawine@5: 	} : false,
sawine@5: 	xhrId = 0,
sawine@5: 	xhrCallbacks;
sawine@5: 
sawine@5: // Functions to create xhrs
sawine@5: function createStandardXHR() {
sawine@5: 	try {
sawine@5: 		return new window.XMLHttpRequest();
sawine@5: 	} catch( e ) {}
sawine@5: }
sawine@5: 
sawine@5: function createActiveXHR() {
sawine@5: 	try {
sawine@5: 		return new window.ActiveXObject( "Microsoft.XMLHTTP" );
sawine@5: 	} catch( e ) {}
sawine@5: }
sawine@5: 
sawine@5: // Create the request object
sawine@5: // (This is still attached to ajaxSettings for backward compatibility)
sawine@5: jQuery.ajaxSettings.xhr = window.ActiveXObject ?
sawine@5: 	/* Microsoft failed to properly
sawine@5: 	 * implement the XMLHttpRequest in IE7 (can't request local files),
sawine@5: 	 * so we use the ActiveXObject when it is available
sawine@5: 	 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
sawine@5: 	 * we need a fallback.
sawine@5: 	 */
sawine@5: 	function() {
sawine@5: 		return !this.isLocal && createStandardXHR() || createActiveXHR();
sawine@5: 	} :
sawine@5: 	// For all other browsers, use the standard XMLHttpRequest object
sawine@5: 	createStandardXHR;
sawine@5: 
sawine@5: // Determine support properties
sawine@5: (function( xhr ) {
sawine@5: 	jQuery.extend( jQuery.support, {
sawine@5: 		ajax: !!xhr,
sawine@5: 		cors: !!xhr && ( "withCredentials" in xhr )
sawine@5: 	});
sawine@5: })( jQuery.ajaxSettings.xhr() );
sawine@5: 
sawine@5: // Create transport if the browser can provide an xhr
sawine@5: if ( jQuery.support.ajax ) {
sawine@5: 
sawine@5: 	jQuery.ajaxTransport(function( s ) {
sawine@5: 		// Cross domain only allowed if supported through XMLHttpRequest
sawine@5: 		if ( !s.crossDomain || jQuery.support.cors ) {
sawine@5: 
sawine@5: 			var callback;
sawine@5: 
sawine@5: 			return {
sawine@5: 				send: function( headers, complete ) {
sawine@5: 
sawine@5: 					// Get a new xhr
sawine@5: 					var xhr = s.xhr(),
sawine@5: 						handle,
sawine@5: 						i;
sawine@5: 
sawine@5: 					// Open the socket
sawine@5: 					// Passing null username, generates a login popup on Opera (#2865)
sawine@5: 					if ( s.username ) {
sawine@5: 						xhr.open( s.type, s.url, s.async, s.username, s.password );
sawine@5: 					} else {
sawine@5: 						xhr.open( s.type, s.url, s.async );
sawine@5: 					}
sawine@5: 
sawine@5: 					// Apply custom fields if provided
sawine@5: 					if ( s.xhrFields ) {
sawine@5: 						for ( i in s.xhrFields ) {
sawine@5: 							xhr[ i ] = s.xhrFields[ i ];
sawine@5: 						}
sawine@5: 					}
sawine@5: 
sawine@5: 					// Override mime type if needed
sawine@5: 					if ( s.mimeType && xhr.overrideMimeType ) {
sawine@5: 						xhr.overrideMimeType( s.mimeType );
sawine@5: 					}
sawine@5: 
sawine@5: 					// X-Requested-With header
sawine@5: 					// For cross-domain requests, seeing as conditions for a preflight are
sawine@5: 					// akin to a jigsaw puzzle, we simply never set it to be sure.
sawine@5: 					// (it can always be set on a per-request basis or even using ajaxSetup)
sawine@5: 					// For same-domain requests, won't change header if already provided.
sawine@5: 					if ( !s.crossDomain && !headers["X-Requested-With"] ) {
sawine@5: 						headers[ "X-Requested-With" ] = "XMLHttpRequest";
sawine@5: 					}
sawine@5: 
sawine@5: 					// Need an extra try/catch for cross domain requests in Firefox 3
sawine@5: 					try {
sawine@5: 						for ( i in headers ) {
sawine@5: 							xhr.setRequestHeader( i, headers[ i ] );
sawine@5: 						}
sawine@5: 					} catch( _ ) {}
sawine@5: 
sawine@5: 					// Do send the request
sawine@5: 					// This may raise an exception which is actually
sawine@5: 					// handled in jQuery.ajax (so no try/catch here)
sawine@5: 					xhr.send( ( s.hasContent && s.data ) || null );
sawine@5: 
sawine@5: 					// Listener
sawine@5: 					callback = function( _, isAbort ) {
sawine@5: 
sawine@5: 						var status,
sawine@5: 							statusText,
sawine@5: 							responseHeaders,
sawine@5: 							responses,
sawine@5: 							xml;
sawine@5: 
sawine@5: 						// Firefox throws exceptions when accessing properties
sawine@5: 						// of an xhr when a network error occured
sawine@5: 						// http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
sawine@5: 						try {
sawine@5: 
sawine@5: 							// Was never called and is aborted or complete
sawine@5: 							if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
sawine@5: 
sawine@5: 								// Only called once
sawine@5: 								callback = undefined;
sawine@5: 
sawine@5: 								// Do not keep as active anymore
sawine@5: 								if ( handle ) {
sawine@5: 									xhr.onreadystatechange = jQuery.noop;
sawine@5: 									if ( xhrOnUnloadAbort ) {
sawine@5: 										delete xhrCallbacks[ handle ];
sawine@5: 									}
sawine@5: 								}
sawine@5: 
sawine@5: 								// If it's an abort
sawine@5: 								if ( isAbort ) {
sawine@5: 									// Abort it manually if needed
sawine@5: 									if ( xhr.readyState !== 4 ) {
sawine@5: 										xhr.abort();
sawine@5: 									}
sawine@5: 								} else {
sawine@5: 									status = xhr.status;
sawine@5: 									responseHeaders = xhr.getAllResponseHeaders();
sawine@5: 									responses = {};
sawine@5: 									xml = xhr.responseXML;
sawine@5: 
sawine@5: 									// Construct response list
sawine@5: 									if ( xml && xml.documentElement /* #4958 */ ) {
sawine@5: 										responses.xml = xml;
sawine@5: 									}
sawine@5: 									responses.text = xhr.responseText;
sawine@5: 
sawine@5: 									// Firefox throws an exception when accessing
sawine@5: 									// statusText for faulty cross-domain requests
sawine@5: 									try {
sawine@5: 										statusText = xhr.statusText;
sawine@5: 									} catch( e ) {
sawine@5: 										// We normalize with Webkit giving an empty statusText
sawine@5: 										statusText = "";
sawine@5: 									}
sawine@5: 
sawine@5: 									// Filter status for non standard behaviors
sawine@5: 
sawine@5: 									// If the request is local and we have data: assume a success
sawine@5: 									// (success with no data won't get notified, that's the best we
sawine@5: 									// can do given current implementations)
sawine@5: 									if ( !status && s.isLocal && !s.crossDomain ) {
sawine@5: 										status = responses.text ? 200 : 404;
sawine@5: 									// IE - #1450: sometimes returns 1223 when it should be 204
sawine@5: 									} else if ( status === 1223 ) {
sawine@5: 										status = 204;
sawine@5: 									}
sawine@5: 								}
sawine@5: 							}
sawine@5: 						} catch( firefoxAccessException ) {
sawine@5: 							if ( !isAbort ) {
sawine@5: 								complete( -1, firefoxAccessException );
sawine@5: 							}
sawine@5: 						}
sawine@5: 
sawine@5: 						// Call complete if needed
sawine@5: 						if ( responses ) {
sawine@5: 							complete( status, statusText, responses, responseHeaders );
sawine@5: 						}
sawine@5: 					};
sawine@5: 
sawine@5: 					// if we're in sync mode or it's in cache
sawine@5: 					// and has been retrieved directly (IE6 & IE7)
sawine@5: 					// we need to manually fire the callback
sawine@5: 					if ( !s.async || xhr.readyState === 4 ) {
sawine@5: 						callback();
sawine@5: 					} else {
sawine@5: 						handle = ++xhrId;
sawine@5: 						if ( xhrOnUnloadAbort ) {
sawine@5: 							// Create the active xhrs callbacks list if needed
sawine@5: 							// and attach the unload handler
sawine@5: 							if ( !xhrCallbacks ) {
sawine@5: 								xhrCallbacks = {};
sawine@5: 								jQuery( window ).unload( xhrOnUnloadAbort );
sawine@5: 							}
sawine@5: 							// Add to list of active xhrs callbacks
sawine@5: 							xhrCallbacks[ handle ] = callback;
sawine@5: 						}
sawine@5: 						xhr.onreadystatechange = callback;
sawine@5: 					}
sawine@5: 				},
sawine@5: 
sawine@5: 				abort: function() {
sawine@5: 					if ( callback ) {
sawine@5: 						callback(0,1);
sawine@5: 					}
sawine@5: 				}
sawine@5: 			};
sawine@5: 		}
sawine@5: 	});
sawine@5: }
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: var elemdisplay = {},
sawine@5: 	iframe, iframeDoc,
sawine@5: 	rfxtypes = /^(?:toggle|show|hide)$/,
sawine@5: 	rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
sawine@5: 	timerId,
sawine@5: 	fxAttrs = [
sawine@5: 		// height animations
sawine@5: 		[ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
sawine@5: 		// width animations
sawine@5: 		[ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
sawine@5: 		// opacity animations
sawine@5: 		[ "opacity" ]
sawine@5: 	],
sawine@5: 	fxNow;
sawine@5: 
sawine@5: jQuery.fn.extend({
sawine@5: 	show: function( speed, easing, callback ) {
sawine@5: 		var elem, display;
sawine@5: 
sawine@5: 		if ( speed || speed === 0 ) {
sawine@5: 			return this.animate( genFx("show", 3), speed, easing, callback);
sawine@5: 
sawine@5: 		} else {
sawine@5: 			for ( var i = 0, j = this.length; i < j; i++ ) {
sawine@5: 				elem = this[i];
sawine@5: 
sawine@5: 				if ( elem.style ) {
sawine@5: 					display = elem.style.display;
sawine@5: 
sawine@5: 					// Reset the inline display of this element to learn if it is
sawine@5: 					// being hidden by cascaded rules or not
sawine@5: 					if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
sawine@5: 						display = elem.style.display = "";
sawine@5: 					}
sawine@5: 
sawine@5: 					// Set elements which have been overridden with display: none
sawine@5: 					// in a stylesheet to whatever the default browser style is
sawine@5: 					// for such an element
sawine@5: 					if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
sawine@5: 						jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			// Set the display of most of the elements in a second loop
sawine@5: 			// to avoid the constant reflow
sawine@5: 			for ( i = 0; i < j; i++ ) {
sawine@5: 				elem = this[i];
sawine@5: 
sawine@5: 				if ( elem.style ) {
sawine@5: 					display = elem.style.display;
sawine@5: 
sawine@5: 					if ( display === "" || display === "none" ) {
sawine@5: 						elem.style.display = jQuery._data(elem, "olddisplay") || "";
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			return this;
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	hide: function( speed, easing, callback ) {
sawine@5: 		if ( speed || speed === 0 ) {
sawine@5: 			return this.animate( genFx("hide", 3), speed, easing, callback);
sawine@5: 
sawine@5: 		} else {
sawine@5: 			for ( var i = 0, j = this.length; i < j; i++ ) {
sawine@5: 				if ( this[i].style ) {
sawine@5: 					var display = jQuery.css( this[i], "display" );
sawine@5: 
sawine@5: 					if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) {
sawine@5: 						jQuery._data( this[i], "olddisplay", display );
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			// Set the display of the elements in a second loop
sawine@5: 			// to avoid the constant reflow
sawine@5: 			for ( i = 0; i < j; i++ ) {
sawine@5: 				if ( this[i].style ) {
sawine@5: 					this[i].style.display = "none";
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			return this;
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	// Save the old toggle function
sawine@5: 	_toggle: jQuery.fn.toggle,
sawine@5: 
sawine@5: 	toggle: function( fn, fn2, callback ) {
sawine@5: 		var bool = typeof fn === "boolean";
sawine@5: 
sawine@5: 		if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
sawine@5: 			this._toggle.apply( this, arguments );
sawine@5: 
sawine@5: 		} else if ( fn == null || bool ) {
sawine@5: 			this.each(function() {
sawine@5: 				var state = bool ? fn : jQuery(this).is(":hidden");
sawine@5: 				jQuery(this)[ state ? "show" : "hide" ]();
sawine@5: 			});
sawine@5: 
sawine@5: 		} else {
sawine@5: 			this.animate(genFx("toggle", 3), fn, fn2, callback);
sawine@5: 		}
sawine@5: 
sawine@5: 		return this;
sawine@5: 	},
sawine@5: 
sawine@5: 	fadeTo: function( speed, to, easing, callback ) {
sawine@5: 		return this.filter(":hidden").css("opacity", 0).show().end()
sawine@5: 					.animate({opacity: to}, speed, easing, callback);
sawine@5: 	},
sawine@5: 
sawine@5: 	animate: function( prop, speed, easing, callback ) {
sawine@5: 		var optall = jQuery.speed(speed, easing, callback);
sawine@5: 
sawine@5: 		if ( jQuery.isEmptyObject( prop ) ) {
sawine@5: 			return this.each( optall.complete, [ false ] );
sawine@5: 		}
sawine@5: 
sawine@5: 		// Do not change referenced properties as per-property easing will be lost
sawine@5: 		prop = jQuery.extend( {}, prop );
sawine@5: 
sawine@5: 		return this[ optall.queue === false ? "each" : "queue" ](function() {
sawine@5: 			// XXX 'this' does not always have a nodeName when running the
sawine@5: 			// test suite
sawine@5: 
sawine@5: 			if ( optall.queue === false ) {
sawine@5: 				jQuery._mark( this );
sawine@5: 			}
sawine@5: 
sawine@5: 			var opt = jQuery.extend( {}, optall ),
sawine@5: 				isElement = this.nodeType === 1,
sawine@5: 				hidden = isElement && jQuery(this).is(":hidden"),
sawine@5: 				name, val, p,
sawine@5: 				display, e,
sawine@5: 				parts, start, end, unit;
sawine@5: 
sawine@5: 			// will store per property easing and be used to determine when an animation is complete
sawine@5: 			opt.animatedProperties = {};
sawine@5: 
sawine@5: 			for ( p in prop ) {
sawine@5: 
sawine@5: 				// property name normalization
sawine@5: 				name = jQuery.camelCase( p );
sawine@5: 				if ( p !== name ) {
sawine@5: 					prop[ name ] = prop[ p ];
sawine@5: 					delete prop[ p ];
sawine@5: 				}
sawine@5: 
sawine@5: 				val = prop[ name ];
sawine@5: 
sawine@5: 				// easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
sawine@5: 				if ( jQuery.isArray( val ) ) {
sawine@5: 					opt.animatedProperties[ name ] = val[ 1 ];
sawine@5: 					val = prop[ name ] = val[ 0 ];
sawine@5: 				} else {
sawine@5: 					opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] || opt.easing || 'swing';
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( val === "hide" && hidden || val === "show" && !hidden ) {
sawine@5: 					return opt.complete.call( this );
sawine@5: 				}
sawine@5: 
sawine@5: 				if ( isElement && ( name === "height" || name === "width" ) ) {
sawine@5: 					// Make sure that nothing sneaks out
sawine@5: 					// Record all 3 overflow attributes because IE does not
sawine@5: 					// change the overflow attribute when overflowX and
sawine@5: 					// overflowY are set to the same value
sawine@5: 					opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
sawine@5: 
sawine@5: 					// Set display property to inline-block for height/width
sawine@5: 					// animations on inline elements that are having width/height
sawine@5: 					// animated
sawine@5: 					if ( jQuery.css( this, "display" ) === "inline" &&
sawine@5: 							jQuery.css( this, "float" ) === "none" ) {
sawine@5: 						if ( !jQuery.support.inlineBlockNeedsLayout ) {
sawine@5: 							this.style.display = "inline-block";
sawine@5: 
sawine@5: 						} else {
sawine@5: 							display = defaultDisplay( this.nodeName );
sawine@5: 
sawine@5: 							// inline-level elements accept inline-block;
sawine@5: 							// block-level elements need to be inline with layout
sawine@5: 							if ( display === "inline" ) {
sawine@5: 								this.style.display = "inline-block";
sawine@5: 
sawine@5: 							} else {
sawine@5: 								this.style.display = "inline";
sawine@5: 								this.style.zoom = 1;
sawine@5: 							}
sawine@5: 						}
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( opt.overflow != null ) {
sawine@5: 				this.style.overflow = "hidden";
sawine@5: 			}
sawine@5: 
sawine@5: 			for ( p in prop ) {
sawine@5: 				e = new jQuery.fx( this, opt, p );
sawine@5: 				val = prop[ p ];
sawine@5: 
sawine@5: 				if ( rfxtypes.test(val) ) {
sawine@5: 					e[ val === "toggle" ? hidden ? "show" : "hide" : val ]();
sawine@5: 
sawine@5: 				} else {
sawine@5: 					parts = rfxnum.exec( val );
sawine@5: 					start = e.cur();
sawine@5: 
sawine@5: 					if ( parts ) {
sawine@5: 						end = parseFloat( parts[2] );
sawine@5: 						unit = parts[3] || ( jQuery.cssNumber[ p ] ? "" : "px" );
sawine@5: 
sawine@5: 						// We need to compute starting value
sawine@5: 						if ( unit !== "px" ) {
sawine@5: 							jQuery.style( this, p, (end || 1) + unit);
sawine@5: 							start = ((end || 1) / e.cur()) * start;
sawine@5: 							jQuery.style( this, p, start + unit);
sawine@5: 						}
sawine@5: 
sawine@5: 						// If a +=/-= token was provided, we're doing a relative animation
sawine@5: 						if ( parts[1] ) {
sawine@5: 							end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
sawine@5: 						}
sawine@5: 
sawine@5: 						e.custom( start, end, unit );
sawine@5: 
sawine@5: 					} else {
sawine@5: 						e.custom( start, val, "" );
sawine@5: 					}
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			// For JS strict compliance
sawine@5: 			return true;
sawine@5: 		});
sawine@5: 	},
sawine@5: 
sawine@5: 	stop: function( clearQueue, gotoEnd ) {
sawine@5: 		if ( clearQueue ) {
sawine@5: 			this.queue([]);
sawine@5: 		}
sawine@5: 
sawine@5: 		this.each(function() {
sawine@5: 			var timers = jQuery.timers,
sawine@5: 				i = timers.length;
sawine@5: 			// clear marker counters if we know they won't be
sawine@5: 			if ( !gotoEnd ) {
sawine@5: 				jQuery._unmark( true, this );
sawine@5: 			}
sawine@5: 			while ( i-- ) {
sawine@5: 				if ( timers[i].elem === this ) {
sawine@5: 					if (gotoEnd) {
sawine@5: 						// force the next step to be the last
sawine@5: 						timers[i](true);
sawine@5: 					}
sawine@5: 
sawine@5: 					timers.splice(i, 1);
sawine@5: 				}
sawine@5: 			}
sawine@5: 		});
sawine@5: 
sawine@5: 		// start the next in the queue if the last step wasn't forced
sawine@5: 		if ( !gotoEnd ) {
sawine@5: 			this.dequeue();
sawine@5: 		}
sawine@5: 
sawine@5: 		return this;
sawine@5: 	}
sawine@5: 
sawine@5: });
sawine@5: 
sawine@5: // Animations created synchronously will run synchronously
sawine@5: function createFxNow() {
sawine@5: 	setTimeout( clearFxNow, 0 );
sawine@5: 	return ( fxNow = jQuery.now() );
sawine@5: }
sawine@5: 
sawine@5: function clearFxNow() {
sawine@5: 	fxNow = undefined;
sawine@5: }
sawine@5: 
sawine@5: // Generate parameters to create a standard animation
sawine@5: function genFx( type, num ) {
sawine@5: 	var obj = {};
sawine@5: 
sawine@5: 	jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
sawine@5: 		obj[ this ] = type;
sawine@5: 	});
sawine@5: 
sawine@5: 	return obj;
sawine@5: }
sawine@5: 
sawine@5: // Generate shortcuts for custom animations
sawine@5: jQuery.each({
sawine@5: 	slideDown: genFx("show", 1),
sawine@5: 	slideUp: genFx("hide", 1),
sawine@5: 	slideToggle: genFx("toggle", 1),
sawine@5: 	fadeIn: { opacity: "show" },
sawine@5: 	fadeOut: { opacity: "hide" },
sawine@5: 	fadeToggle: { opacity: "toggle" }
sawine@5: }, function( name, props ) {
sawine@5: 	jQuery.fn[ name ] = function( speed, easing, callback ) {
sawine@5: 		return this.animate( props, speed, easing, callback );
sawine@5: 	};
sawine@5: });
sawine@5: 
sawine@5: jQuery.extend({
sawine@5: 	speed: function( speed, easing, fn ) {
sawine@5: 		var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
sawine@5: 			complete: fn || !fn && easing ||
sawine@5: 				jQuery.isFunction( speed ) && speed,
sawine@5: 			duration: speed,
sawine@5: 			easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
sawine@5: 		};
sawine@5: 
sawine@5: 		opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
sawine@5: 			opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
sawine@5: 
sawine@5: 		// Queueing
sawine@5: 		opt.old = opt.complete;
sawine@5: 		opt.complete = function( noUnmark ) {
sawine@5: 			if ( jQuery.isFunction( opt.old ) ) {
sawine@5: 				opt.old.call( this );
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( opt.queue !== false ) {
sawine@5: 				jQuery.dequeue( this );
sawine@5: 			} else if ( noUnmark !== false ) {
sawine@5: 				jQuery._unmark( this );
sawine@5: 			}
sawine@5: 		};
sawine@5: 
sawine@5: 		return opt;
sawine@5: 	},
sawine@5: 
sawine@5: 	easing: {
sawine@5: 		linear: function( p, n, firstNum, diff ) {
sawine@5: 			return firstNum + diff * p;
sawine@5: 		},
sawine@5: 		swing: function( p, n, firstNum, diff ) {
sawine@5: 			return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	timers: [],
sawine@5: 
sawine@5: 	fx: function( elem, options, prop ) {
sawine@5: 		this.options = options;
sawine@5: 		this.elem = elem;
sawine@5: 		this.prop = prop;
sawine@5: 
sawine@5: 		options.orig = options.orig || {};
sawine@5: 	}
sawine@5: 
sawine@5: });
sawine@5: 
sawine@5: jQuery.fx.prototype = {
sawine@5: 	// Simple function for setting a style value
sawine@5: 	update: function() {
sawine@5: 		if ( this.options.step ) {
sawine@5: 			this.options.step.call( this.elem, this.now, this );
sawine@5: 		}
sawine@5: 
sawine@5: 		(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
sawine@5: 	},
sawine@5: 
sawine@5: 	// Get the current size
sawine@5: 	cur: function() {
sawine@5: 		if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
sawine@5: 			return this.elem[ this.prop ];
sawine@5: 		}
sawine@5: 
sawine@5: 		var parsed,
sawine@5: 			r = jQuery.css( this.elem, this.prop );
sawine@5: 		// Empty strings, null, undefined and "auto" are converted to 0,
sawine@5: 		// complex values such as "rotate(1rad)" are returned as is,
sawine@5: 		// simple values such as "10px" are parsed to Float.
sawine@5: 		return isNaN( parsed = parseFloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
sawine@5: 	},
sawine@5: 
sawine@5: 	// Start an animation from one number to another
sawine@5: 	custom: function( from, to, unit ) {
sawine@5: 		var self = this,
sawine@5: 			fx = jQuery.fx;
sawine@5: 
sawine@5: 		this.startTime = fxNow || createFxNow();
sawine@5: 		this.start = from;
sawine@5: 		this.end = to;
sawine@5: 		this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
sawine@5: 		this.now = this.start;
sawine@5: 		this.pos = this.state = 0;
sawine@5: 
sawine@5: 		function t( gotoEnd ) {
sawine@5: 			return self.step(gotoEnd);
sawine@5: 		}
sawine@5: 
sawine@5: 		t.elem = this.elem;
sawine@5: 
sawine@5: 		if ( t() && jQuery.timers.push(t) && !timerId ) {
sawine@5: 			timerId = setInterval( fx.tick, fx.interval );
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	// Simple 'show' function
sawine@5: 	show: function() {
sawine@5: 		// Remember where we started, so that we can go back to it later
sawine@5: 		this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
sawine@5: 		this.options.show = true;
sawine@5: 
sawine@5: 		// Begin the animation
sawine@5: 		// Make sure that we start at a small width/height to avoid any
sawine@5: 		// flash of content
sawine@5: 		this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
sawine@5: 
sawine@5: 		// Start by showing the element
sawine@5: 		jQuery( this.elem ).show();
sawine@5: 	},
sawine@5: 
sawine@5: 	// Simple 'hide' function
sawine@5: 	hide: function() {
sawine@5: 		// Remember where we started, so that we can go back to it later
sawine@5: 		this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
sawine@5: 		this.options.hide = true;
sawine@5: 
sawine@5: 		// Begin the animation
sawine@5: 		this.custom(this.cur(), 0);
sawine@5: 	},
sawine@5: 
sawine@5: 	// Each step of an animation
sawine@5: 	step: function( gotoEnd ) {
sawine@5: 		var t = fxNow || createFxNow(),
sawine@5: 			done = true,
sawine@5: 			elem = this.elem,
sawine@5: 			options = this.options,
sawine@5: 			i, n;
sawine@5: 
sawine@5: 		if ( gotoEnd || t >= options.duration + this.startTime ) {
sawine@5: 			this.now = this.end;
sawine@5: 			this.pos = this.state = 1;
sawine@5: 			this.update();
sawine@5: 
sawine@5: 			options.animatedProperties[ this.prop ] = true;
sawine@5: 
sawine@5: 			for ( i in options.animatedProperties ) {
sawine@5: 				if ( options.animatedProperties[i] !== true ) {
sawine@5: 					done = false;
sawine@5: 				}
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( done ) {
sawine@5: 				// Reset the overflow
sawine@5: 				if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
sawine@5: 
sawine@5: 					jQuery.each( [ "", "X", "Y" ], function (index, value) {
sawine@5: 						elem.style[ "overflow" + value ] = options.overflow[index];
sawine@5: 					});
sawine@5: 				}
sawine@5: 
sawine@5: 				// Hide the element if the "hide" operation was done
sawine@5: 				if ( options.hide ) {
sawine@5: 					jQuery(elem).hide();
sawine@5: 				}
sawine@5: 
sawine@5: 				// Reset the properties, if the item has been hidden or shown
sawine@5: 				if ( options.hide || options.show ) {
sawine@5: 					for ( var p in options.animatedProperties ) {
sawine@5: 						jQuery.style( elem, p, options.orig[p] );
sawine@5: 					}
sawine@5: 				}
sawine@5: 
sawine@5: 				// Execute the complete function
sawine@5: 				options.complete.call( elem );
sawine@5: 			}
sawine@5: 
sawine@5: 			return false;
sawine@5: 
sawine@5: 		} else {
sawine@5: 			// classical easing cannot be used with an Infinity duration
sawine@5: 			if ( options.duration == Infinity ) {
sawine@5: 				this.now = t;
sawine@5: 			} else {
sawine@5: 				n = t - this.startTime;
sawine@5: 				this.state = n / options.duration;
sawine@5: 
sawine@5: 				// Perform the easing function, defaults to swing
sawine@5: 				this.pos = jQuery.easing[ options.animatedProperties[ this.prop ] ]( this.state, n, 0, 1, options.duration );
sawine@5: 				this.now = this.start + ((this.end - this.start) * this.pos);
sawine@5: 			}
sawine@5: 			// Perform the next step of the animation
sawine@5: 			this.update();
sawine@5: 		}
sawine@5: 
sawine@5: 		return true;
sawine@5: 	}
sawine@5: };
sawine@5: 
sawine@5: jQuery.extend( jQuery.fx, {
sawine@5: 	tick: function() {
sawine@5: 		for ( var timers = jQuery.timers, i = 0 ; i < timers.length ; ++i ) {
sawine@5: 			if ( !timers[i]() ) {
sawine@5: 				timers.splice(i--, 1);
sawine@5: 			}
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( !timers.length ) {
sawine@5: 			jQuery.fx.stop();
sawine@5: 		}
sawine@5: 	},
sawine@5: 
sawine@5: 	interval: 13,
sawine@5: 
sawine@5: 	stop: function() {
sawine@5: 		clearInterval( timerId );
sawine@5: 		timerId = null;
sawine@5: 	},
sawine@5: 
sawine@5: 	speeds: {
sawine@5: 		slow: 600,
sawine@5: 		fast: 200,
sawine@5: 		// Default speed
sawine@5: 		_default: 400
sawine@5: 	},
sawine@5: 
sawine@5: 	step: {
sawine@5: 		opacity: function( fx ) {
sawine@5: 			jQuery.style( fx.elem, "opacity", fx.now );
sawine@5: 		},
sawine@5: 
sawine@5: 		_default: function( fx ) {
sawine@5: 			if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
sawine@5: 				fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
sawine@5: 			} else {
sawine@5: 				fx.elem[ fx.prop ] = fx.now;
sawine@5: 			}
sawine@5: 		}
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: if ( jQuery.expr && jQuery.expr.filters ) {
sawine@5: 	jQuery.expr.filters.animated = function( elem ) {
sawine@5: 		return jQuery.grep(jQuery.timers, function( fn ) {
sawine@5: 			return elem === fn.elem;
sawine@5: 		}).length;
sawine@5: 	};
sawine@5: }
sawine@5: 
sawine@5: // Try to restore the default display value of an element
sawine@5: function defaultDisplay( nodeName ) {
sawine@5: 
sawine@5: 	if ( !elemdisplay[ nodeName ] ) {
sawine@5: 
sawine@5: 		var body = document.body,
sawine@5: 			elem = jQuery( "<" + nodeName + ">" ).appendTo( body ),
sawine@5: 			display = elem.css( "display" );
sawine@5: 
sawine@5: 		elem.remove();
sawine@5: 
sawine@5: 		// If the simple way fails,
sawine@5: 		// get element's real default display by attaching it to a temp iframe
sawine@5: 		if ( display === "none" || display === "" ) {
sawine@5: 			// No iframe to use yet, so create it
sawine@5: 			if ( !iframe ) {
sawine@5: 				iframe = document.createElement( "iframe" );
sawine@5: 				iframe.frameBorder = iframe.width = iframe.height = 0;
sawine@5: 			}
sawine@5: 
sawine@5: 			body.appendChild( iframe );
sawine@5: 
sawine@5: 			// Create a cacheable copy of the iframe document on first call.
sawine@5: 			// IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML
sawine@5: 			// document to it; WebKit & Firefox won't allow reusing the iframe document.
sawine@5: 			if ( !iframeDoc || !iframe.createElement ) {
sawine@5: 				iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
sawine@5: 				iframeDoc.write( ( document.compatMode === "CSS1Compat" ? "<!doctype html>" : "" ) + "<html><body>" );
sawine@5: 				iframeDoc.close();
sawine@5: 			}
sawine@5: 
sawine@5: 			elem = iframeDoc.createElement( nodeName );
sawine@5: 
sawine@5: 			iframeDoc.body.appendChild( elem );
sawine@5: 
sawine@5: 			display = jQuery.css( elem, "display" );
sawine@5: 
sawine@5: 			body.removeChild( iframe );
sawine@5: 		}
sawine@5: 
sawine@5: 		// Store the correct default display
sawine@5: 		elemdisplay[ nodeName ] = display;
sawine@5: 	}
sawine@5: 
sawine@5: 	return elemdisplay[ nodeName ];
sawine@5: }
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: var rtable = /^t(?:able|d|h)$/i,
sawine@5: 	rroot = /^(?:body|html)$/i;
sawine@5: 
sawine@5: if ( "getBoundingClientRect" in document.documentElement ) {
sawine@5: 	jQuery.fn.offset = function( options ) {
sawine@5: 		var elem = this[0], box;
sawine@5: 
sawine@5: 		if ( options ) {
sawine@5: 			return this.each(function( i ) {
sawine@5: 				jQuery.offset.setOffset( this, options, i );
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( !elem || !elem.ownerDocument ) {
sawine@5: 			return null;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( elem === elem.ownerDocument.body ) {
sawine@5: 			return jQuery.offset.bodyOffset( elem );
sawine@5: 		}
sawine@5: 
sawine@5: 		try {
sawine@5: 			box = elem.getBoundingClientRect();
sawine@5: 		} catch(e) {}
sawine@5: 
sawine@5: 		var doc = elem.ownerDocument,
sawine@5: 			docElem = doc.documentElement;
sawine@5: 
sawine@5: 		// Make sure we're not dealing with a disconnected DOM node
sawine@5: 		if ( !box || !jQuery.contains( docElem, elem ) ) {
sawine@5: 			return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
sawine@5: 		}
sawine@5: 
sawine@5: 		var body = doc.body,
sawine@5: 			win = getWindow(doc),
sawine@5: 			clientTop  = docElem.clientTop  || body.clientTop  || 0,
sawine@5: 			clientLeft = docElem.clientLeft || body.clientLeft || 0,
sawine@5: 			scrollTop  = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop,
sawine@5: 			scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft,
sawine@5: 			top  = box.top  + scrollTop  - clientTop,
sawine@5: 			left = box.left + scrollLeft - clientLeft;
sawine@5: 
sawine@5: 		return { top: top, left: left };
sawine@5: 	};
sawine@5: 
sawine@5: } else {
sawine@5: 	jQuery.fn.offset = function( options ) {
sawine@5: 		var elem = this[0];
sawine@5: 
sawine@5: 		if ( options ) {
sawine@5: 			return this.each(function( i ) {
sawine@5: 				jQuery.offset.setOffset( this, options, i );
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( !elem || !elem.ownerDocument ) {
sawine@5: 			return null;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( elem === elem.ownerDocument.body ) {
sawine@5: 			return jQuery.offset.bodyOffset( elem );
sawine@5: 		}
sawine@5: 
sawine@5: 		jQuery.offset.initialize();
sawine@5: 
sawine@5: 		var computedStyle,
sawine@5: 			offsetParent = elem.offsetParent,
sawine@5: 			prevOffsetParent = elem,
sawine@5: 			doc = elem.ownerDocument,
sawine@5: 			docElem = doc.documentElement,
sawine@5: 			body = doc.body,
sawine@5: 			defaultView = doc.defaultView,
sawine@5: 			prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
sawine@5: 			top = elem.offsetTop,
sawine@5: 			left = elem.offsetLeft;
sawine@5: 
sawine@5: 		while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
sawine@5: 			if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
sawine@5: 				break;
sawine@5: 			}
sawine@5: 
sawine@5: 			computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
sawine@5: 			top  -= elem.scrollTop;
sawine@5: 			left -= elem.scrollLeft;
sawine@5: 
sawine@5: 			if ( elem === offsetParent ) {
sawine@5: 				top  += elem.offsetTop;
sawine@5: 				left += elem.offsetLeft;
sawine@5: 
sawine@5: 				if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
sawine@5: 					top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
sawine@5: 					left += parseFloat( computedStyle.borderLeftWidth ) || 0;
sawine@5: 				}
sawine@5: 
sawine@5: 				prevOffsetParent = offsetParent;
sawine@5: 				offsetParent = elem.offsetParent;
sawine@5: 			}
sawine@5: 
sawine@5: 			if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
sawine@5: 				top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
sawine@5: 				left += parseFloat( computedStyle.borderLeftWidth ) || 0;
sawine@5: 			}
sawine@5: 
sawine@5: 			prevComputedStyle = computedStyle;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
sawine@5: 			top  += body.offsetTop;
sawine@5: 			left += body.offsetLeft;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
sawine@5: 			top  += Math.max( docElem.scrollTop, body.scrollTop );
sawine@5: 			left += Math.max( docElem.scrollLeft, body.scrollLeft );
sawine@5: 		}
sawine@5: 
sawine@5: 		return { top: top, left: left };
sawine@5: 	};
sawine@5: }
sawine@5: 
sawine@5: jQuery.offset = {
sawine@5: 	initialize: function() {
sawine@5: 		var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
sawine@5: 			html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
sawine@5: 
sawine@5: 		jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
sawine@5: 
sawine@5: 		container.innerHTML = html;
sawine@5: 		body.insertBefore( container, body.firstChild );
sawine@5: 		innerDiv = container.firstChild;
sawine@5: 		checkDiv = innerDiv.firstChild;
sawine@5: 		td = innerDiv.nextSibling.firstChild.firstChild;
sawine@5: 
sawine@5: 		this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
sawine@5: 		this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
sawine@5: 
sawine@5: 		checkDiv.style.position = "fixed";
sawine@5: 		checkDiv.style.top = "20px";
sawine@5: 
sawine@5: 		// safari subtracts parent border width here which is 5px
sawine@5: 		this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
sawine@5: 		checkDiv.style.position = checkDiv.style.top = "";
sawine@5: 
sawine@5: 		innerDiv.style.overflow = "hidden";
sawine@5: 		innerDiv.style.position = "relative";
sawine@5: 
sawine@5: 		this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
sawine@5: 
sawine@5: 		this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
sawine@5: 
sawine@5: 		body.removeChild( container );
sawine@5: 		jQuery.offset.initialize = jQuery.noop;
sawine@5: 	},
sawine@5: 
sawine@5: 	bodyOffset: function( body ) {
sawine@5: 		var top = body.offsetTop,
sawine@5: 			left = body.offsetLeft;
sawine@5: 
sawine@5: 		jQuery.offset.initialize();
sawine@5: 
sawine@5: 		if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
sawine@5: 			top  += parseFloat( jQuery.css(body, "marginTop") ) || 0;
sawine@5: 			left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
sawine@5: 		}
sawine@5: 
sawine@5: 		return { top: top, left: left };
sawine@5: 	},
sawine@5: 
sawine@5: 	setOffset: function( elem, options, i ) {
sawine@5: 		var position = jQuery.css( elem, "position" );
sawine@5: 
sawine@5: 		// set position first, in-case top/left are set even on static elem
sawine@5: 		if ( position === "static" ) {
sawine@5: 			elem.style.position = "relative";
sawine@5: 		}
sawine@5: 
sawine@5: 		var curElem = jQuery( elem ),
sawine@5: 			curOffset = curElem.offset(),
sawine@5: 			curCSSTop = jQuery.css( elem, "top" ),
sawine@5: 			curCSSLeft = jQuery.css( elem, "left" ),
sawine@5: 			calculatePosition = (position === "absolute" || position === "fixed") && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
sawine@5: 			props = {}, curPosition = {}, curTop, curLeft;
sawine@5: 
sawine@5: 		// need to be able to calculate position if either top or left is auto and position is either absolute or fixed
sawine@5: 		if ( calculatePosition ) {
sawine@5: 			curPosition = curElem.position();
sawine@5: 			curTop = curPosition.top;
sawine@5: 			curLeft = curPosition.left;
sawine@5: 		} else {
sawine@5: 			curTop = parseFloat( curCSSTop ) || 0;
sawine@5: 			curLeft = parseFloat( curCSSLeft ) || 0;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( jQuery.isFunction( options ) ) {
sawine@5: 			options = options.call( elem, i, curOffset );
sawine@5: 		}
sawine@5: 
sawine@5: 		if (options.top != null) {
sawine@5: 			props.top = (options.top - curOffset.top) + curTop;
sawine@5: 		}
sawine@5: 		if (options.left != null) {
sawine@5: 			props.left = (options.left - curOffset.left) + curLeft;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( "using" in options ) {
sawine@5: 			options.using.call( elem, props );
sawine@5: 		} else {
sawine@5: 			curElem.css( props );
sawine@5: 		}
sawine@5: 	}
sawine@5: };
sawine@5: 
sawine@5: 
sawine@5: jQuery.fn.extend({
sawine@5: 	position: function() {
sawine@5: 		if ( !this[0] ) {
sawine@5: 			return null;
sawine@5: 		}
sawine@5: 
sawine@5: 		var elem = this[0],
sawine@5: 
sawine@5: 		// Get *real* offsetParent
sawine@5: 		offsetParent = this.offsetParent(),
sawine@5: 
sawine@5: 		// Get correct offsets
sawine@5: 		offset       = this.offset(),
sawine@5: 		parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
sawine@5: 
sawine@5: 		// Subtract element margins
sawine@5: 		// note: when an element has margin: auto the offsetLeft and marginLeft
sawine@5: 		// are the same in Safari causing offset.left to incorrectly be 0
sawine@5: 		offset.top  -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
sawine@5: 		offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
sawine@5: 
sawine@5: 		// Add offsetParent borders
sawine@5: 		parentOffset.top  += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
sawine@5: 		parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
sawine@5: 
sawine@5: 		// Subtract the two offsets
sawine@5: 		return {
sawine@5: 			top:  offset.top  - parentOffset.top,
sawine@5: 			left: offset.left - parentOffset.left
sawine@5: 		};
sawine@5: 	},
sawine@5: 
sawine@5: 	offsetParent: function() {
sawine@5: 		return this.map(function() {
sawine@5: 			var offsetParent = this.offsetParent || document.body;
sawine@5: 			while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
sawine@5: 				offsetParent = offsetParent.offsetParent;
sawine@5: 			}
sawine@5: 			return offsetParent;
sawine@5: 		});
sawine@5: 	}
sawine@5: });
sawine@5: 
sawine@5: 
sawine@5: // Create scrollLeft and scrollTop methods
sawine@5: jQuery.each( ["Left", "Top"], function( i, name ) {
sawine@5: 	var method = "scroll" + name;
sawine@5: 
sawine@5: 	jQuery.fn[ method ] = function( val ) {
sawine@5: 		var elem, win;
sawine@5: 
sawine@5: 		if ( val === undefined ) {
sawine@5: 			elem = this[ 0 ];
sawine@5: 
sawine@5: 			if ( !elem ) {
sawine@5: 				return null;
sawine@5: 			}
sawine@5: 
sawine@5: 			win = getWindow( elem );
sawine@5: 
sawine@5: 			// Return the scroll offset
sawine@5: 			return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
sawine@5: 				jQuery.support.boxModel && win.document.documentElement[ method ] ||
sawine@5: 					win.document.body[ method ] :
sawine@5: 				elem[ method ];
sawine@5: 		}
sawine@5: 
sawine@5: 		// Set the scroll offset
sawine@5: 		return this.each(function() {
sawine@5: 			win = getWindow( this );
sawine@5: 
sawine@5: 			if ( win ) {
sawine@5: 				win.scrollTo(
sawine@5: 					!i ? val : jQuery( win ).scrollLeft(),
sawine@5: 					 i ? val : jQuery( win ).scrollTop()
sawine@5: 				);
sawine@5: 
sawine@5: 			} else {
sawine@5: 				this[ method ] = val;
sawine@5: 			}
sawine@5: 		});
sawine@5: 	};
sawine@5: });
sawine@5: 
sawine@5: function getWindow( elem ) {
sawine@5: 	return jQuery.isWindow( elem ) ?
sawine@5: 		elem :
sawine@5: 		elem.nodeType === 9 ?
sawine@5: 			elem.defaultView || elem.parentWindow :
sawine@5: 			false;
sawine@5: }
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: 
sawine@5: // Create width, height, innerHeight, innerWidth, outerHeight and outerWidth methods
sawine@5: jQuery.each([ "Height", "Width" ], function( i, name ) {
sawine@5: 
sawine@5: 	var type = name.toLowerCase();
sawine@5: 
sawine@5: 	// innerHeight and innerWidth
sawine@5: 	jQuery.fn[ "inner" + name ] = function() {
sawine@5: 		var elem = this[0];
sawine@5: 		return elem && elem.style ?
sawine@5: 			parseFloat( jQuery.css( elem, type, "padding" ) ) :
sawine@5: 			null;
sawine@5: 	};
sawine@5: 
sawine@5: 	// outerHeight and outerWidth
sawine@5: 	jQuery.fn[ "outer" + name ] = function( margin ) {
sawine@5: 		var elem = this[0];
sawine@5: 		return elem && elem.style ?
sawine@5: 			parseFloat( jQuery.css( elem, type, margin ? "margin" : "border" ) ) :
sawine@5: 			null;
sawine@5: 	};
sawine@5: 
sawine@5: 	jQuery.fn[ type ] = function( size ) {
sawine@5: 		// Get window width or height
sawine@5: 		var elem = this[0];
sawine@5: 		if ( !elem ) {
sawine@5: 			return size == null ? null : this;
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( jQuery.isFunction( size ) ) {
sawine@5: 			return this.each(function( i ) {
sawine@5: 				var self = jQuery( this );
sawine@5: 				self[ type ]( size.call( this, i, self[ type ]() ) );
sawine@5: 			});
sawine@5: 		}
sawine@5: 
sawine@5: 		if ( jQuery.isWindow( elem ) ) {
sawine@5: 			// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
sawine@5: 			// 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
sawine@5: 			var docElemProp = elem.document.documentElement[ "client" + name ],
sawine@5: 				body = elem.document.body;
sawine@5: 			return elem.document.compatMode === "CSS1Compat" && docElemProp ||
sawine@5: 				body && body[ "client" + name ] || docElemProp;
sawine@5: 
sawine@5: 		// Get document width or height
sawine@5: 		} else if ( elem.nodeType === 9 ) {
sawine@5: 			// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
sawine@5: 			return Math.max(
sawine@5: 				elem.documentElement["client" + name],
sawine@5: 				elem.body["scroll" + name], elem.documentElement["scroll" + name],
sawine@5: 				elem.body["offset" + name], elem.documentElement["offset" + name]
sawine@5: 			);
sawine@5: 
sawine@5: 		// Get or set width or height on the element
sawine@5: 		} else if ( size === undefined ) {
sawine@5: 			var orig = jQuery.css( elem, type ),
sawine@5: 				ret = parseFloat( orig );
sawine@5: 
sawine@5: 			return jQuery.isNaN( ret ) ? orig : ret;
sawine@5: 
sawine@5: 		// Set the width or height on the element (default to pixels if value is unitless)
sawine@5: 		} else {
sawine@5: 			return this.css( type, typeof size === "string" ? size : size + "px" );
sawine@5: 		}
sawine@5: 	};
sawine@5: 
sawine@5: });
sawine@5: 
sawine@5: 
sawine@5: // Expose jQuery to the global object
sawine@5: window.jQuery = window.$ = jQuery;
sawine@5: })(window);