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