diff options
| author |   ramverma <ram.krishna.verma@ericsson.com> | 2018-07-11 14:21:13 +0100 |
|---|---|---|
| committer | ramverma <ram.krishna.verma@ericsson.com> | 2018-07-12 17:40:19 +0100 |
| commit | c6d74e6cee17405b9d26506b06259ccb2f38c737 (patch) | |
| tree | 9f5dabe5ceffe0e6b99a2bf77be812657953ae9b /client/client-common/src/main/resources/jquery | |
| parent | b461c6505afddacbef90e3dc0bfa9d49609a626b (diff) | |
Adding client deployment module to apex-pdp
Change-Id: Idd74e9846c3fa75d305a9dde98a98d92dd0520a9
Issue-ID: POLICY-864
Signed-off-by: ramverma <ram.krishna.verma@ericsson.com>
Diffstat (limited to 'client/client-common/src/main/resources/jquery')
| -rw-r--r-- | client/client-common/src/main/resources/jquery/jquery-1.12.4.js | 11551 |
1 files changed, 11551 insertions, 0 deletions
diff --git a/client/client-common/src/main/resources/jquery/jquery-1.12.4.js b/client/client-common/src/main/resources/jquery/jquery-1.12.4.js new file mode 100644 index 000000000..b038fc51f --- /dev/null +++ b/client/client-common/src/main/resources/jquery/jquery-1.12.4.js @@ -0,0 +1,11551 @@ +/*! + * jQuery JavaScript Library v1.12.4 + * http://jquery.com/ + * + * Includes Sizzle.js + * http://sizzlejs.com/ + * + * Copyright jQuery Foundation and other contributors + * Released under the MIT license + * http://jquery.org/license + * + * Date: 2016-05-20T17:17Z + */ + +(function(global, factory) { + + if (typeof module === "object" && typeof module.exports === "object") { + // For CommonJS and CommonJS-like environments where a proper `window` + // is present, execute the factory and get jQuery. + // For environments that do not have a `window` with a `document` + // (such as Node.js), expose a factory as module.exports. + // This accentuates the need for the creation of a real `window`. + // e.g. var jQuery = require("jquery")(window); + // See ticket #14549 for more info. + module.exports = global.document ? factory(global, true) : function(w) { + if (!w.document) { + throw new Error("jQuery requires a window with a document"); + } + return factory(w); + }; + } else { + factory(global); + } + + // Pass this if window is not defined yet +} + ( + typeof window !== "undefined" ? window : this, + function(window, noGlobal) { + + // Support: Firefox 18+ + // Can't be in strict mode, several libs including ASP.NET + // trace + // the stack via arguments.caller.callee and Firefox dies if + // you try to trace through "use strict" call chains. + // (#13335) + // "use strict"; + var deletedIds = []; + + var document = window.document; + + var slice = deletedIds.slice; + + var concat = deletedIds.concat; + + var push = deletedIds.push; + + var indexOf = deletedIds.indexOf; + + var class2type = {}; + + var toString = class2type.toString; + + var hasOwn = class2type.hasOwnProperty; + + var support = {}; + + var version = "1.12.4", + + // Define a local copy of jQuery + jQuery = function(selector, context) { + + // The jQuery object is actually just the init + // constructor 'enhanced' + // Need init if jQuery is called (just allow error to be + // thrown if not included) + return new jQuery.fn.init(selector, context); + }, + + // Support: Android<4.1, IE<9 + // Make sure we trim BOM and NBSP + rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, + + // Matches dashed string for camelizing + rmsPrefix = /^-ms-/, rdashAlpha = /-([\da-z])/gi, + + // Used by jQuery.camelCase as callback to replace() + fcamelCase = function(all, letter) { + return letter.toUpperCase(); + }; + + jQuery.fn = jQuery.prototype = { + + // The current version of jQuery being used + jquery : version, + + constructor : jQuery, + + // Start with an empty selector + selector : "", + + // The default length of a jQuery object is 0 + length : 0, + + toArray : function() { + return slice.call(this); + }, + + // 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 just the one element from the set + (num < 0 ? this[num + this.length] : this[num]) : + + // Return all the elements in a clean array + slice.call(this); + }, + + // Take an array of elements and push it onto the stack + // (returning the new matched element set) + pushStack : function(elems) { + + // Build a new jQuery matched element set + var ret = jQuery.merge(this.constructor(), elems); + + // Add the old object onto the stack (as a + // reference) + ret.prevObject = this; + ret.context = this.context; + + // Return the newly-formed element set + return ret; + }, + + // Execute a callback for every element in the matched + // set. + each : function(callback) { + return jQuery.each(this, callback); + }, + + map : function(callback) { + return this.pushStack(jQuery.map(this, function(elem, i) { + return callback.call(elem, i, elem); + })); + }, + + slice : function() { + return this.pushStack(slice.apply(this, arguments)); + }, + + first : function() { + return this.eq(0); + }, + + last : function() { + return this.eq(-1); + }, + + eq : function(i) { + var len = this.length, j = +i + (i < 0 ? len : 0); + return this.pushStack(j >= 0 && j < len ? [ this[j] ] : []); + }, + + end : function() { + return this.prevObject || this.constructor(); + }, + + // For internal use only. + // Behaves like an Array's method, not like a jQuery + // method. + push : push, + sort : deletedIds.sort, + splice : deletedIds.splice + }; + + jQuery.extend = jQuery.fn.extend = function() { + var src, copyIsArray, copy, name, options, clone, target = arguments[0] || {}, i = 1, length = arguments.length, deep = false; + + // Handle a deep copy situation + if (typeof target === "boolean") { + deep = target; + + // skip the boolean and the target + target = arguments[i] || {}; + i++; + } + + // 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 (i === length) { + 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({ + + // Unique for each copy of jQuery on the page + expando : "jQuery" + (version + Math.random()).replace(/\D/g, ""), + + // Assume jQuery is ready without the ready + // module + isReady : true, + + error : function(msg) { + throw new Error(msg); + }, + + noop : function() { + }, + + // 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) { + /* jshint eqeqeq: false */ + return obj != null && obj == obj.window; + }, + + isNumeric : function(obj) { + + // parseFloat NaNs numeric-cast false + // positives (null|true|false|"") + // ...but misinterprets leading-number + // strings, particularly hex literals + // ("0x...") + // subtraction forces infinities to NaN + // adding 1 corrects loss of precision from + // parseFloat (#15100) + var realStringObj = obj && obj.toString(); + return !jQuery.isArray(obj) && (realStringObj - parseFloat(realStringObj) + 1) >= 0; + }, + + isEmptyObject : function(obj) { + var name; + for (name in obj) { + return false; + } + return true; + }, + + isPlainObject : function(obj) { + var key; + + // 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; + } + + // Support: IE<9 + // Handle iteration over inherited + // properties before own properties. + if (!support.ownFirst) { + for (key in obj) { + return hasOwn.call(obj, key); + } + } + + // Own properties are enumerated firstly, so + // to speed up, + // if last one is own, then all properties + // are own. + for (key in obj) { + } + + return key === undefined || hasOwn.call(obj, key); + }, + + type : function(obj) { + if (obj == null) { + return obj + ""; + } + return typeof obj === "object" || typeof obj === "function" ? class2type[toString + .call(obj)] + || "object" : typeof obj; + }, + + // 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 && jQuery.trim(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); // jscs:ignore + // requireDotNotation + })(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.toLowerCase() === name.toLowerCase(); + }, + + each : function(obj, callback) { + var length, i = 0; + + if (isArrayLike(obj)) { + length = obj.length; + for (; i < length; i++) { + if (callback.call(obj[i], i, obj[i]) === false) { + break; + } + } + } else { + for (i in obj) { + if (callback.call(obj[i], i, obj[i]) === false) { + break; + } + } + } + + return obj; + }, + + // Support: Android<4.1, IE<9 + trim : function(text) { + return text == null ? "" : (text + "").replace(rtrim, ""); + }, + + // results is for internal usage only + makeArray : function(arr, results) { + var ret = results || []; + + if (arr != null) { + if (isArrayLike(Object(arr))) { + jQuery.merge(ret, typeof arr === "string" ? [ arr ] : arr); + } else { + push.call(ret, arr); + } + } + + return ret; + }, + + inArray : function(elem, arr, i) { + var len; + + if (arr) { + if (indexOf) { + return indexOf.call(arr, elem, i); + } + + len = arr.length; + i = i ? i < 0 ? Math.max(0, len + i) : i : 0; + + for (; i < len; i++) { + + // Skip accessing in sparse arrays + if (i in arr && arr[i] === elem) { + return i; + } + } + } + + return -1; + }, + + merge : function(first, second) { + var len = +second.length, j = 0, i = first.length; + + while (j < len) { + first[i++] = second[j++]; + } + + // Support: IE<9 + // Workaround casting of .length to NaN on + // otherwise arraylike objects (e.g., + // NodeLists) + if (len !== len) { + while (second[j] !== undefined) { + first[i++] = second[j++]; + } + } + + first.length = i; + + return first; + }, + + grep : function(elems, callback, invert) { + var callbackInverse, matches = [], i = 0, length = elems.length, callbackExpect = !invert; + + // Go through the array, only saving the + // items + // that pass the validator function + for (; i < length; i++) { + callbackInverse = !callback(elems[i], i); + if (callbackInverse !== callbackExpect) { + matches.push(elems[i]); + } + } + + return matches; + }, + + // arg is for internal usage only + map : function(elems, callback, arg) { + var length, value, i = 0, ret = []; + + // Go through the array, translating each of + // the items to their new values + if (isArrayLike(elems)) { + length = elems.length; + for (; i < length; i++) { + value = callback(elems[i], i, arg); + + if (value != null) { + ret.push(value); + } + } + + // Go through every key on the object, + } else { + for (i in elems) { + value = callback(elems[i], i, arg); + + if (value != null) { + ret.push(value); + } + } + } + + // Flatten any nested arrays + return 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) { + var args, proxy, tmp; + + if (typeof context === "string") { + 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 + args = slice.call(arguments, 2); + proxy = function() { + return fn.apply(context || this, 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 || jQuery.guid++; + + return proxy; + }, + + now : function() { + return +(new Date()); + }, + + // jQuery.support is not used in Core but other + // projects attach their + // properties to it so it needs to exist. + support : support + }); + + // JSHint would error on this code due to the Symbol not + // being defined in ES5. + // Defining this global in .jshintrc would create a danger + // of using the global + // unguarded in another place, it seems safer to just + // disable JSHint for these + // three lines. + /* jshint ignore: start */ + if (typeof Symbol === "function") { + jQuery.fn[Symbol.iterator] = deletedIds[Symbol.iterator]; + } + /* jshint ignore: end */ + + // Populate the class2type map + jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), + function(i, name) { + class2type["[object " + name + "]"] = name.toLowerCase(); + }); + + function isArrayLike(obj) { + + // Support: iOS 8.2 (not reproducible in simulator) + // `in` check used to prevent JIT error (gh-2145) + // hasOwn isn't used here due to false negatives + // regarding Nodelist length in IE + var length = !!obj && "length" in obj && obj.length, type = jQuery.type(obj); + + if (type === "function" || jQuery.isWindow(obj)) { + return false; + } + + return type === "array" || length === 0 || typeof length === "number" && length > 0 + && (length - 1) in obj; + } + var Sizzle = + /* + * ! Sizzle CSS Selector Engine v2.2.1 http://sizzlejs.com/ + * + * Copyright jQuery Foundation and other contributors + * Released under the MIT license http://jquery.org/license + * + * Date: 2015-10-17 + */ + (function(window) { + + var i, support, Expr, getText, isXML, tokenize, compile, select, outermostContext, sortInput, hasDuplicate, + + // Local document vars + setDocument, document, docElem, documentIsHTML, rbuggyQSA, rbuggyMatches, matches, contains, + + // Instance-specific data + expando = "sizzle" + 1 * new Date(), preferredDoc = window.document, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), sortOrder = function( + a, b) { + if (a === b) { + hasDuplicate = true; + } + return 0; + }, + + // General-purpose constants + MAX_NEGATIVE = 1 << 31, + + // Instance methods + hasOwn = ({}).hasOwnProperty, arr = [], pop = arr.pop, push_native = arr.push, push = arr.push, slice = arr.slice, + // Use a stripped-down indexOf as it's faster than + // native + // http://jsperf.com/thor-indexof-vs-for/5 + indexOf = function(list, elem) { + var i = 0, len = list.length; + for (; i < len; i++) { + if (list[i] === elem) { + return i; + } + } + return -1; + }, + + booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", + + // Regular expressions + + // http://www.w3.org/TR/css3-selectors/#whitespace + whitespace = "[\\x20\\t\\r\\n\\f]", + + // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier + identifier = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+", + + // Attribute selectors: + // http://www.w3.org/TR/selectors/#attribute-selectors + attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + + // Operator (capture 2) + "*([*^$|!~]?=)" + whitespace + + // "Attribute values must be CSS identifiers + // [capture 5] or strings [capture 3 or capture + // 4]" + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + + "*\\]", + + pseudos = ":(" + identifier + ")(?:\\((" + + // To reduce the number of selectors needing tokenize in + // the preFilter, prefer arguments: + // 1. quoted (capture 3; capture 4 or capture 5) + "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + + // 2. simple (capture 6) + "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + + // 3. anything else (capture 2) + ".*" + ")\\)|)", + + // Leading and non-escaped trailing whitespace, + // capturing some non-whitespace characters preceding + // the latter + rwhitespace = new RegExp(whitespace + "+", "g"), rtrim = new RegExp("^" + whitespace + + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"), + + rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"), rcombinators = new RegExp("^" + + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"), + + rattributeQuotes = new RegExp("=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g"), + + rpseudo = new RegExp(pseudos), ridentifier = new RegExp("^" + identifier + "$"), + + matchExpr = { + "ID" : new RegExp("^#(" + identifier + ")"), + "CLASS" : new RegExp("^\\.(" + identifier + ")"), + "TAG" : new RegExp("^(" + identifier + "|[*])"), + "ATTR" : new RegExp("^" + attributes), + "PSEUDO" : new RegExp("^" + pseudos), + "CHILD" : new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + + "*(\\d+)|))" + whitespace + "*\\)|)", "i"), + "bool" : new RegExp("^(?:" + booleans + ")$", "i"), + // For use in libraries implementing .is() + // We use this for POS matching in `select` + "needsContext" : new RegExp("^" + whitespace + + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i") + }, + + rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, + + rnative = /^[^{]+\{\s*\[native \w/, + + // Easily-parseable/retrievable ID or TAG or CLASS + // selectors + rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, + + rsibling = /[+~]/, rescape = /'|\\/g, + + // CSS escapes + // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters + runescape = new RegExp("\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig"), funescape = function( + _, escaped, escapedWhitespace) { + var high = "0x" + escaped - 0x10000; + // NaN means non-codepoint + // Support: Firefox<24 + // Workaround erroneous numeric interpretation of + // +"0x" + return high !== high || escapedWhitespace ? escaped : high < 0 ? + // BMP codepoint + String.fromCharCode(high + 0x10000) : + // Supplemental Plane codepoint (surrogate + // pair) + String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00); + }, + + // Used for iframes + // See setDocument() + // Removing the function wrapper causes a "Permission + // Denied" + // error in IE + unloadHandler = function() { + setDocument(); + }; + + // Optimize for push.apply( _, NodeList ) + try { + push.apply((arr = slice.call(preferredDoc.childNodes)), preferredDoc.childNodes); + // Support: Android<4.0 + // Detect silently failing push.apply + arr[preferredDoc.childNodes.length].nodeType; + } catch (e) { + push = { + apply : arr.length ? + + // Leverage slice if possible + function(target, els) { + push_native.apply(target, slice.call(els)); + } : + + // Support: IE<9 + // Otherwise append directly + function(target, els) { + var j = target.length, i = 0; + // Can't trust NodeList.length + while ((target[j++] = els[i++])) { + } + target.length = j - 1; + } + }; + } + + function Sizzle(selector, context, results, seed) { + var m, i, elem, nid, nidselect, match, groups, newSelector, newContext = context + && context.ownerDocument, + + // nodeType defaults to 9, since context defaults to + // document + nodeType = context ? context.nodeType : 9; + + results = results || []; + + // Return early from calls with invalid selector or + // context + if (typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 + && nodeType !== 11) { + + return results; + } + + // Try to shortcut find operations (as opposed to + // filters) in HTML documents + if (!seed) { + + if ((context ? context.ownerDocument || context : preferredDoc) !== document) { + setDocument(context); + } + context = context || document; + + if (documentIsHTML) { + + // If the selector is sufficiently simple, + // try using a "get*By*" DOM method + // (excepting DocumentFragment context, + // where the methods don't exist) + if (nodeType !== 11 && (match = rquickExpr.exec(selector))) { + + // ID selector + if ((m = match[1])) { + + // Document context + if (nodeType === 9) { + if ((elem = context.getElementById(m))) { + + // Support: IE, Opera, + // Webkit + // TODO: identify versions + // getElementById can match + // elements by name instead + // of ID + if (elem.id === m) { + results.push(elem); + return results; + } + } else { + return results; + } + + // Element context + } else { + + // Support: IE, Opera, Webkit + // TODO: identify versions + // getElementById can match + // elements by name instead of + // ID + if (newContext && (elem = newContext.getElementById(m)) + && contains(context, elem) && elem.id === m) { + + results.push(elem); + return results; + } + } + + // Type selector + } else if (match[2]) { + push.apply(results, context.getElementsByTagName(selector)); + return results; + + // Class selector + } else if ((m = match[3]) && support.getElementsByClassName + && context.getElementsByClassName) { + + push.apply(results, context.getElementsByClassName(m)); + return results; + } + } + + // Take advantage of querySelectorAll + if (support.qsa && !compilerCache[selector + " "] + && (!rbuggyQSA || !rbuggyQSA.test(selector))) { + + if (nodeType !== 1) { + newContext = context; + newSelector = selector; + + // qSA looks outside Element + // context, which is not what we + // want + // Thanks to Andrew Dupont for this + // workaround technique + // Support: IE <=8 + // Exclude object elements + } else if (context.nodeName.toLowerCase() !== "object") { + + // Capture the context ID, setting + // it first if necessary + if ((nid = context.getAttribute("id"))) { + nid = nid.replace(rescape, "\\$&"); + } else { + context.setAttribute("id", (nid = expando)); + } + + // Prefix every selector in the list + groups = tokenize(selector); + i = groups.length; + nidselect = ridentifier.test(nid) ? "#" + nid : "[id='" + nid + "']"; + while (i--) { + groups[i] = nidselect + " " + toSelector(groups[i]); + } + newSelector = groups.join(","); + + // Expand context for sibling + // selectors + newContext = rsibling.test(selector) && testContext(context.parentNode) + || context; + } + + if (newSelector) { + try { + push.apply(results, newContext.querySelectorAll(newSelector)); + return results; + } catch (qsaError) { + } finally { + if (nid === expando) { + context.removeAttribute("id"); + } + } + } + } + } + } + + // All others + return select(selector.replace(rtrim, "$1"), context, results, seed); + } + + /** + * Create key-value caches of limited size + * + * @returns {function(string, object)} Returns the + * Object data after storing it on itself with + * property name the (space-suffixed) string + * and (if the cache is larger than + * Expr.cacheLength) deleting the oldest entry + */ + function createCache() { + var keys = []; + + function cache(key, value) { + // Use (key + " ") to avoid collision with + // native prototype properties (see Issue #157) + if (keys.push(key + " ") > Expr.cacheLength) { + // Only keep the most recent entries + delete cache[keys.shift()]; + } + return (cache[key + " "] = value); + } + return cache; + } + + /** + * Mark a function for special use by Sizzle + * + * @param {Function} + * fn The function to mark + */ + function markFunction(fn) { + fn[expando] = true; + return fn; + } + + /** + * Support testing using an element + * + * @param {Function} + * fn Passed the created div and expects a + * boolean result + */ + function assert(fn) { + var div = document.createElement("div"); + + try { + return !!fn(div); + } catch (e) { + return false; + } finally { + // Remove from its parent by default + if (div.parentNode) { + div.parentNode.removeChild(div); + } + // release memory in IE + div = null; + } + } + + /** + * Adds the same handler for all of the specified attrs + * + * @param {String} + * attrs Pipe-separated list of attributes + * @param {Function} + * handler The method that will be applied + */ + function addHandle(attrs, handler) { + var arr = attrs.split("|"), i = arr.length; + + while (i--) { + Expr.attrHandle[arr[i]] = handler; + } + } + + /** + * Checks document order of two siblings + * + * @param {Element} + * a + * @param {Element} + * b + * @returns {Number} Returns less than 0 if a precedes + * b, greater than 0 if a follows b + */ + function siblingCheck(a, b) { + var cur = b && a, diff = cur && a.nodeType === 1 && b.nodeType === 1 + && (~b.sourceIndex || MAX_NEGATIVE) - (~a.sourceIndex || MAX_NEGATIVE); + + // Use IE sourceIndex if available on both nodes + if (diff) { + return diff; + } + + // Check if b follows a + if (cur) { + while ((cur = cur.nextSibling)) { + if (cur === b) { + return -1; + } + } + } + + return a ? 1 : -1; + } + + /** + * Returns a function to use in pseudos for input types + * + * @param {String} + * type + */ + function createInputPseudo(type) { + return function(elem) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && elem.type === type; + }; + } + + /** + * Returns a function to use in pseudos for buttons + * + * @param {String} + * type + */ + function createButtonPseudo(type) { + return function(elem) { + var name = elem.nodeName.toLowerCase(); + return (name === "input" || name === "button") && elem.type === type; + }; + } + + /** + * Returns a function to use in pseudos for positionals + * + * @param {Function} + * fn + */ + function createPositionalPseudo(fn) { + return markFunction(function(argument) { + argument = +argument; + return markFunction(function(seed, matches) { + var j, matchIndexes = fn([], seed.length, argument), i = matchIndexes.length; + + // Match elements found at the specified + // indexes + while (i--) { + if (seed[(j = matchIndexes[i])]) { + seed[j] = !(matches[j] = seed[j]); + } + } + }); + }); + } + + /** + * Checks a node for validity as a Sizzle context + * + * @param {Element|Object=} + * context + * @returns {Element|Object|Boolean} The input node if + * acceptable, otherwise a falsy value + */ + function testContext(context) { + return context && typeof context.getElementsByTagName !== "undefined" && context; + } + + // Expose support vars for convenience + support = Sizzle.support = {}; + + /** + * Detects XML nodes + * + * @param {Element|Object} + * elem An element or a document + * @returns {Boolean} True iff elem is a non-HTML XML + * node + */ + isXML = 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).documentElement; + return documentElement ? documentElement.nodeName !== "HTML" : false; + }; + + /** + * Sets document-related variables once based on the + * current document + * + * @param {Element|Object} + * [doc] An element or document object to use + * to set the document + * @returns {Object} Returns the current document + */ + setDocument = Sizzle.setDocument = function(node) { + var hasCompare, parent, doc = node ? node.ownerDocument || node : preferredDoc; + + // Return early if doc is invalid or already + // selected + if (doc === document || doc.nodeType !== 9 || !doc.documentElement) { + return document; + } + + // Update global variables + document = doc; + docElem = document.documentElement; + documentIsHTML = !isXML(document); + + // Support: IE 9-11, Edge + // Accessing iframe documents after unload throws + // "permission denied" errors (jQuery #13936) + if ((parent = document.defaultView) && parent.top !== parent) { + // Support: IE 11 + if (parent.addEventListener) { + parent.addEventListener("unload", unloadHandler, false); + + // Support: IE 9 - 10 only + } else if (parent.attachEvent) { + parent.attachEvent("onunload", unloadHandler); + } + } + + /* + * Attributes + * ---------------------------------------------------------------------- + */ + + // Support: IE<8 + // Verify that getAttribute really returns + // attributes and not properties + // (excepting IE8 booleans) + support.attributes = assert(function(div) { + div.className = "i"; + return !div.getAttribute("className"); + }); + + /*************************************************** + * getElement(s)By + * ---------------------------------------------------------------------- + */ + + // Check if getElementsByTagName("*") returns only + // elements + support.getElementsByTagName = assert(function(div) { + div.appendChild(document.createComment("")); + return !div.getElementsByTagName("*").length; + }); + + // Support: IE<9 + support.getElementsByClassName = rnative.test(document.getElementsByClassName); + + // Support: IE<10 + // Check if getElementById returns elements by name + // The broken getElementById methods don't pick up + // programatically-set names, + // so use a roundabout getElementsByName test + support.getById = assert(function(div) { + docElem.appendChild(div).id = expando; + return !document.getElementsByName || !document.getElementsByName(expando).length; + }); + + // ID find and filter + if (support.getById) { + Expr.find["ID"] = function(id, context) { + if (typeof context.getElementById !== "undefined" && documentIsHTML) { + var m = context.getElementById(id); + return m ? [ m ] : []; + } + }; + Expr.filter["ID"] = function(id) { + var attrId = id.replace(runescape, funescape); + return function(elem) { + return elem.getAttribute("id") === attrId; + }; + }; + } else { + // Support: IE6/7 + // getElementById is not reliable as a find + // shortcut + delete Expr.find["ID"]; + + Expr.filter["ID"] = function(id) { + var attrId = id.replace(runescape, funescape); + return function(elem) { + var node = typeof elem.getAttributeNode !== "undefined" + && elem.getAttributeNode("id"); + return node && node.value === attrId; + }; + }; + } + + // Tag + Expr.find["TAG"] = support.getElementsByTagName ? function(tag, context) { + if (typeof context.getElementsByTagName !== "undefined") { + return context.getElementsByTagName(tag); + + // DocumentFragment nodes don't have gEBTN + } else if (support.qsa) { + return context.querySelectorAll(tag); + } + } : + + function(tag, context) { + var elem, tmp = [], i = 0, + // By happy coincidence, a (broken) + // gEBTN appears on DocumentFragment + // nodes too + results = context.getElementsByTagName(tag); + + // Filter out possible comments + if (tag === "*") { + while ((elem = results[i++])) { + if (elem.nodeType === 1) { + tmp.push(elem); + } + } + + return tmp; + } + return results; + }; + + // Class + Expr.find["CLASS"] = support.getElementsByClassName && function(className, context) { + if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) { + return context.getElementsByClassName(className); + } + }; + + /* + * QSA/matchesSelector + * ---------------------------------------------------------------------- + */ + + // QSA and matchesSelector support + // matchesSelector(:active) reports false when true + // (IE9/Opera 11.5) + rbuggyMatches = []; + + // qSa(:focus) reports false when true (Chrome 21) + // We allow this because of a bug in IE8/9 that + // throws an error + // whenever `document.activeElement` is accessed on + // an iframe + // So, we allow :focus to pass through QSA all the + // time to avoid the IE error + // See http://bugs.jquery.com/ticket/13378 + rbuggyQSA = []; + + if ((support.qsa = rnative.test(document.querySelectorAll))) { + // Build QSA regex + // Regex strategy adopted from Diego Perini + assert(function(div) { + // Select is set to empty string on purpose + // This is to test IE's treatment of not + // explicitly + // setting a boolean content attribute, + // since its presence should be enough + // http://bugs.jquery.com/ticket/12359 + docElem.appendChild(div).innerHTML = "<a id='" + expando + "'></a>" + + "<select id='" + expando + "-\r\\' msallowcapture=''>" + + "<option selected=''></option></select>"; + + // Support: IE8, Opera 11-12.16 + // Nothing should be selected when empty + // strings follow ^= or $= or *= + // The test attribute must be unknown in + // Opera but "safe" for WinRT + // http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section + if (div.querySelectorAll("[msallowcapture^='']").length) { + rbuggyQSA.push("[*^$]=" + whitespace + "*(?:''|\"\")"); + } + + // Support: IE8 + // Boolean attributes and "value" are not + // treated correctly + if (!div.querySelectorAll("[selected]").length) { + rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")"); + } + + // Support: Chrome<29, Android<4.4, + // Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ + if (!div.querySelectorAll("[id~=" + expando + "-]").length) { + rbuggyQSA.push("~="); + } + + // Webkit/Opera - :checked should return + // selected option elements + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + // IE8 throws error here and will not see + // later tests + if (!div.querySelectorAll(":checked").length) { + rbuggyQSA.push(":checked"); + } + + // Support: Safari 8+, iOS 8+ + // https://bugs.webkit.org/show_bug.cgi?id=136851 + // In-page `selector#id sibing-combinator + // selector` fails + if (!div.querySelectorAll("a#" + expando + "+*").length) { + rbuggyQSA.push(".#.+[+~]"); + } + }); + + assert(function(div) { + // Support: Windows 8 Native Apps + // The type and name attributes are + // restricted during .innerHTML assignment + var input = document.createElement("input"); + input.setAttribute("type", "hidden"); + div.appendChild(input).setAttribute("name", "D"); + + // Support: IE8 + // Enforce case-sensitivity of name + // attribute + if (div.querySelectorAll("[name=d]").length) { + rbuggyQSA.push("name" + whitespace + "*[*^$|!~]?="); + } + + // FF 3.5 - :enabled/:disabled and hidden + // elements (hidden elements are still + // enabled) + // IE8 throws error here and will not see + // later tests + if (!div.querySelectorAll(":enabled").length) { + rbuggyQSA.push(":enabled", ":disabled"); + } + + // Opera 10-11 does not throw on post-comma + // invalid pseudos + div.querySelectorAll("*,:x"); + rbuggyQSA.push(",.*:"); + }); + } + + if ((support.matchesSelector = rnative.test((matches = docElem.matches + || docElem.webkitMatchesSelector || docElem.mozMatchesSelector + || docElem.oMatchesSelector || docElem.msMatchesSelector)))) { + + assert(function(div) { + // Check to see if it's possible to do + // matchesSelector + // on a disconnected node (IE 9) + support.disconnectedMatch = matches.call(div, "div"); + + // This should fail with an exception + // Gecko does not error, returns false + // instead + matches.call(div, "[s!='']:x"); + rbuggyMatches.push("!=", pseudos); + }); + } + + rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|")); + rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|")); + + /* + * Contains + * ---------------------------------------------------------------------- + */ + hasCompare = rnative.test(docElem.compareDocumentPosition); + + // Element contains another + // Purposefully self-exclusive + // As in, an element does not contain itself + contains = hasCompare || rnative.test(docElem.contains) ? function(a, b) { + var adown = a.nodeType === 9 ? a.documentElement : a, bup = b && b.parentNode; + return a === bup + || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) + : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16)); + } : function(a, b) { + if (b) { + while ((b = b.parentNode)) { + if (b === a) { + return true; + } + } + } + return false; + }; + + /* + * Sorting + * ---------------------------------------------------------------------- + */ + + // Document order sorting + sortOrder = hasCompare ? function(a, b) { + + // Flag for duplicate removal + if (a === b) { + hasDuplicate = true; + return 0; + } + + // Sort on method existence if only one input + // has compareDocumentPosition + var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; + if (compare) { + return compare; + } + + // Calculate position if both inputs belong to + // the same document + compare = (a.ownerDocument || a) === (b.ownerDocument || b) ? a + .compareDocumentPosition(b) : + + // Otherwise we know they are + // disconnected + 1; + + // Disconnected nodes + if (compare & 1 || (!support.sortDetached && b.compareDocumentPosition(a) === compare)) { + + // Choose the first element that is related + // to our preferred document + if (a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a)) { + return -1; + } + if (b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b)) { + return 1; + } + + // Maintain original order + return sortInput ? (indexOf(sortInput, a) - indexOf(sortInput, b)) : 0; + } + + return compare & 4 ? -1 : 1; + } + : function(a, b) { + // Exit early if the nodes are identical + if (a === b) { + hasDuplicate = true; + return 0; + } + + var cur, i = 0, aup = a.parentNode, bup = b.parentNode, ap = [ a ], bp = [ b ]; + + // Parentless nodes are either documents + // or disconnected + if (!aup || !bup) { + return a === document ? -1 : b === document ? 1 : aup ? -1 : bup ? 1 + : sortInput ? (indexOf(sortInput, a) - indexOf(sortInput, b)) : 0; + + // If the nodes are siblings, we can + // do a quick check + } else if (aup === bup) { + return siblingCheck(a, b); + } + + // Otherwise we need full lists of their + // ancestors for comparison + cur = a; + while ((cur = cur.parentNode)) { + ap.unshift(cur); + } + cur = b; + while ((cur = cur.parentNode)) { + bp.unshift(cur); + } + + // Walk down the tree looking for a + // discrepancy + while (ap[i] === bp[i]) { + i++; + } + + return i ? + // Do a sibling check if the nodes have + // a common ancestor + siblingCheck(ap[i], bp[i]) : + + // Otherwise nodes in our document sort + // first + ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0; + }; + + return document; + }; + + Sizzle.matches = function(expr, elements) { + return Sizzle(expr, null, null, elements); + }; + + Sizzle.matchesSelector = function(elem, expr) { + // Set document vars if needed + if ((elem.ownerDocument || elem) !== document) { + setDocument(elem); + } + + // Make sure that attribute selectors are quoted + expr = expr.replace(rattributeQuotes, "='$1']"); + + if (support.matchesSelector && documentIsHTML && !compilerCache[expr + " "] + && (!rbuggyMatches || !rbuggyMatches.test(expr)) + && (!rbuggyQSA || !rbuggyQSA.test(expr))) { + + try { + var ret = matches.call(elem, expr); + + // IE 9's matchesSelector returns false on + // disconnected nodes + if (ret || support.disconnectedMatch || + // As well, disconnected nodes are said to + // be in a document + // fragment in IE 9 + elem.document && elem.document.nodeType !== 11) { + return ret; + } + } catch (e) { + } + } + + return Sizzle(expr, document, null, [ elem ]).length > 0; + }; + + Sizzle.contains = function(context, elem) { + // Set document vars if needed + if ((context.ownerDocument || context) !== document) { + setDocument(context); + } + return contains(context, elem); + }; + + Sizzle.attr = function(elem, name) { + // Set document vars if needed + if ((elem.ownerDocument || elem) !== document) { + setDocument(elem); + } + + var fn = Expr.attrHandle[name.toLowerCase()], + // Don't get fooled by Object.prototype properties + // (jQuery #13807) + val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, + !documentIsHTML) : undefined; + + return val !== undefined ? val : support.attributes || !documentIsHTML ? elem + .getAttribute(name) + : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null; + }; + + Sizzle.error = function(msg) { + throw new Error("Syntax error, unrecognized expression: " + msg); + }; + + /** + * Document sorting and removing duplicates + * + * @param {ArrayLike} + * results + */ + Sizzle.uniqueSort = function(results) { + var elem, duplicates = [], j = 0, i = 0; + + // Unless we *know* we can detect duplicates, assume + // their presence + hasDuplicate = !support.detectDuplicates; + sortInput = !support.sortStable && results.slice(0); + results.sort(sortOrder); + + if (hasDuplicate) { + while ((elem = results[i++])) { + if (elem === results[i]) { + j = duplicates.push(i); + } + } + while (j--) { + results.splice(duplicates[j], 1); + } + } + + // Clear input after sorting to release objects + // See https://github.com/jquery/sizzle/pull/225 + sortInput = null; + + return results; + }; + + /** + * Utility function for retrieving the text value of an + * array of DOM nodes + * + * @param {Array|Element} + * elem + */ + getText = Sizzle.getText = function(elem) { + var node, ret = "", i = 0, nodeType = elem.nodeType; + + if (!nodeType) { + // If no nodeType, this is expected to be an + // array + while ((node = elem[i++])) { + // Do not traverse comment nodes + ret += getText(node); + } + } else if (nodeType === 1 || nodeType === 9 || nodeType === 11) { + // Use textContent for elements + // innerText usage removed for consistency of + // new lines (jQuery #11153) + if (typeof elem.textContent === "string") { + return elem.textContent; + } else { + // Traverse its children + for (elem = elem.firstChild; elem; elem = elem.nextSibling) { + ret += getText(elem); + } + } + } else if (nodeType === 3 || nodeType === 4) { + return elem.nodeValue; + } + // Do not include comment or processing instruction + // nodes + + return ret; + }; + + Expr = Sizzle.selectors = { + + // Can be adjusted by the user + cacheLength : 50, + + createPseudo : markFunction, + + match : matchExpr, + + attrHandle : {}, + + find : {}, + + relative : { + ">" : { + dir : "parentNode", + first : true + }, + " " : { + dir : "parentNode" + }, + "+" : { + dir : "previousSibling", + first : true + }, + "~" : { + dir : "previousSibling" + } + }, + + preFilter : { + "ATTR" : function(match) { + match[1] = match[1].replace(runescape, funescape); + + // Move the given value to match[3] whether + // quoted or unquoted + match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape); + + if (match[2] === "~=") { + match[3] = " " + match[3] + " "; + } + + return match.slice(0, 4); + }, + + "CHILD" : function(match) { + /* + * matches from matchExpr["CHILD"] 1 type + * (only|nth|...) 2 what (child|of-type) 3 + * argument + * (even|odd|\d*|\d*n([+-]\d+)?|...) 4 + * xn-component of xn+y argument + * ([+-]?\d*n|) 5 sign of xn-component 6 x + * of xn-component 7 sign of y-component 8 y + * of y-component + */ + match[1] = match[1].toLowerCase(); + + if (match[1].slice(0, 3) === "nth") { + // nth-* requires argument + if (!match[3]) { + Sizzle.error(match[0]); + } + + // numeric x and y parameters for + // Expr.filter.CHILD + // remember that false/true cast + // respectively to 0/1 + match[4] = +(match[4] ? match[5] + (match[6] || 1) + : 2 * (match[3] === "even" || match[3] === "odd")); + match[5] = +((match[7] + match[8]) || match[3] === "odd"); + + // other types prohibit arguments + } else if (match[3]) { + Sizzle.error(match[0]); + } + + return match; + }, + + "PSEUDO" : function(match) { + var excess, unquoted = !match[6] && match[2]; + + if (matchExpr["CHILD"].test(match[0])) { + return null; + } + + // Accept quoted arguments as-is + if (match[3]) { + match[2] = match[4] || match[5] || ""; + + // Strip excess characters from unquoted + // arguments + } else if (unquoted && rpseudo.test(unquoted) && + // Get excess from tokenize + // (recursively) + (excess = tokenize(unquoted, true)) && + // advance to the next closing + // parenthesis + (excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) { + + // excess is a negative index + match[0] = match[0].slice(0, excess); + match[2] = unquoted.slice(0, excess); + } + + // Return only captures needed by the pseudo + // filter method (type and argument) + return match.slice(0, 3); + } + }, + + filter : { + + "TAG" : function(nodeNameSelector) { + var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase(); + return nodeNameSelector === "*" ? function() { + return true; + } : function(elem) { + return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; + }; + }, + + "CLASS" : function(className) { + var pattern = classCache[className + " "]; + + return pattern + || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + + whitespace + "|$)")) + && classCache(className, function(elem) { + return pattern.test(typeof elem.className === "string" + && elem.className || typeof elem.getAttribute !== "undefined" + && elem.getAttribute("class") || ""); + }); + }, + + "ATTR" : function(name, operator, check) { + return function(elem) { + var result = Sizzle.attr(elem, name); + + if (result == null) { + return operator === "!="; + } + if (!operator) { + return true; + } + + result += ""; + + return operator === "=" ? result === check + : operator === "!=" ? result !== check + : operator === "^=" ? check && result.indexOf(check) === 0 + : operator === "*=" ? check + && result.indexOf(check) > -1 + : operator === "$=" ? check + && result.slice(-check.length) === check + : operator === "~=" ? (" " + + result.replace(rwhitespace, + " ") + " ") + .indexOf(check) > -1 + : operator === "|=" ? result === check + || result + .slice( + 0, + check.length + 1) === check + + "-" + : false; + }; + }, + + "CHILD" : function(type, what, argument, first, last) { + var simple = type.slice(0, 3) !== "nth", forward = type.slice(-4) !== "last", ofType = what === "of-type"; + + return first === 1 && last === 0 ? + + // Shortcut for :nth-*(n) + function(elem) { + return !!elem.parentNode; + } + : + + function(elem, context, xml) { + var cache, uniqueCache, outerCache, node, nodeIndex, start, dir = simple !== forward ? "nextSibling" + : "previousSibling", parent = elem.parentNode, name = ofType + && elem.nodeName.toLowerCase(), useCache = !xml && !ofType, diff = false; + + if (parent) { + + // :(first|last|only)-(child|of-type) + if (simple) { + while (dir) { + node = elem; + while ((node = node[dir])) { + if (ofType ? node.nodeName.toLowerCase() === name + : node.nodeType === 1) { + + return false; + } + } + // Reverse direction + // for :only-* (if + // we haven't yet + // done so) + start = dir = type === "only" && !start && "nextSibling"; + } + return true; + } + + start = [ forward ? parent.firstChild : parent.lastChild ]; + + // non-xml :nth-child(...) + // stores cache data on + // `parent` + if (forward && useCache) { + + // Seek `elem` from a + // previously-cached + // index + + // ...in a gzip-friendly + // way + node = parent; + outerCache = node[expando] || (node[expando] = {}); + + // Support: IE <9 only + // Defend against cloned + // attroperties (jQuery + // gh-1709) + uniqueCache = outerCache[node.uniqueID] + || (outerCache[node.uniqueID] = {}); + + cache = uniqueCache[type] || []; + nodeIndex = cache[0] === dirruns && cache[1]; + diff = nodeIndex && cache[2]; + node = nodeIndex && parent.childNodes[nodeIndex]; + + while ((node = ++nodeIndex && node && node[dir] || + + // Fallback to + // seeking + // `elem` from + // the start + (diff = nodeIndex = 0) || start.pop())) { + + // When found, cache + // indexes on + // `parent` and + // break + if (node.nodeType === 1 && ++diff && node === elem) { + uniqueCache[type] = [ dirruns, nodeIndex, diff ]; + break; + } + } + + } else { + // Use previously-cached + // element index if + // available + if (useCache) { + // ...in a + // gzip-friendly way + node = elem; + outerCache = node[expando] || (node[expando] = {}); + + // Support: IE <9 + // only + // Defend against + // cloned + // attroperties + // (jQuery gh-1709) + uniqueCache = outerCache[node.uniqueID] + || (outerCache[node.uniqueID] = {}); + + cache = uniqueCache[type] || []; + nodeIndex = cache[0] === dirruns && cache[1]; + diff = nodeIndex; + } + + // xml :nth-child(...) + // or + // :nth-last-child(...) + // or + // :nth(-last)?-of-type(...) + if (diff === false) { + // Use the same loop + // as above to seek + // `elem` from the + // start + while ((node = ++nodeIndex && node && node[dir] + || (diff = nodeIndex = 0) || start.pop())) { + + if ((ofType ? node.nodeName.toLowerCase() === name + : node.nodeType === 1) + && ++diff) { + + // Cache the + // index of + // each + // encountered + // element + if (useCache) { + outerCache = node[expando] + || (node[expando] = {}); + + // Support: + // IE <9 + // only + // Defend + // against + // cloned + // attroperties + // (jQuery + // gh-1709) + uniqueCache = outerCache[node.uniqueID] + || (outerCache[node.uniqueID] = {}); + + uniqueCache[type] = [ dirruns, diff ]; + } + + if (node === elem) { + break; + } + } + } + } + } + + // Incorporate the offset, + // then check against cycle + // size + diff -= last; + return diff === first || (diff % first === 0 && diff / first >= 0); + } + }; + }, + + "PSEUDO" : function(pseudo, argument) { + // pseudo-class names are case-insensitive + // http://www.w3.org/TR/selectors/#pseudo-classes + // Prioritize by case sensitivity in case + // custom pseudos are added with uppercase + // letters + // Remember that setFilters inherits from + // pseudos + var args, fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] + || Sizzle.error("unsupported pseudo: " + pseudo); + + // The user may use createPseudo to indicate + // that + // arguments are needed to create the filter + // function + // just as Sizzle does + if (fn[expando]) { + return fn(argument); + } + + // But maintain support for old signatures + if (fn.length > 1) { + args = [ pseudo, pseudo, "", argument ]; + return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function( + seed, matches) { + var idx, matched = fn(seed, argument), i = matched.length; + while (i--) { + idx = indexOf(seed, matched[i]); + seed[idx] = !(matches[idx] = matched[i]); + } + }) + : function(elem) { + return fn(elem, 0, args); + }; + } + + return fn; + } + }, + + pseudos : { + // Potentially complex pseudos + "not" : markFunction(function(selector) { + // Trim the selector passed to compile + // to avoid treating leading and trailing + // spaces as combinators + var input = [], results = [], matcher = compile(selector.replace(rtrim, "$1")); + + return matcher[expando] ? markFunction(function(seed, matches, context, xml) { + var elem, unmatched = matcher(seed, null, xml, []), i = seed.length; + + // Match elements unmatched by `matcher` + while (i--) { + if ((elem = unmatched[i])) { + seed[i] = !(matches[i] = elem); + } + } + }) : function(elem, context, xml) { + input[0] = elem; + matcher(input, null, xml, results); + // Don't keep the element (issue + // #299) + input[0] = null; + return !results.pop(); + }; + }), + + "has" : markFunction(function(selector) { + return function(elem) { + return Sizzle(selector, elem).length > 0; + }; + }), + + "contains" : markFunction(function(text) { + text = text.replace(runescape, funescape); + return function(elem) { + return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1; + }; + }), + + // "Whether an element is represented by a + // :lang() selector + // is based solely on the element's language + // value + // being equal to the identifier C, + // or beginning with the identifier C + // immediately followed by "-". + // The matching of C against the element's + // language value is performed + // case-insensitively. + // The identifier C does not have to be a valid + // language name." + // http://www.w3.org/TR/selectors/#lang-pseudo + "lang" : markFunction(function(lang) { + // lang value must be a valid identifier + if (!ridentifier.test(lang || "")) { + Sizzle.error("unsupported lang: " + lang); + } + lang = lang.replace(runescape, funescape).toLowerCase(); + return function(elem) { + var elemLang; + do { + if ((elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") + || elem.getAttribute("lang"))) { + + elemLang = elemLang.toLowerCase(); + return elemLang === lang || elemLang.indexOf(lang + "-") === 0; + } + } while ((elem = elem.parentNode) && elem.nodeType === 1); + return false; + }; + }), + + // Miscellaneous + "target" : function(elem) { + var hash = window.location && window.location.hash; + return hash && hash.slice(1) === elem.id; + }, + + "root" : function(elem) { + return elem === docElem; + }, + + "focus" : function(elem) { + return elem === document.activeElement + && (!document.hasFocus || document.hasFocus()) + && !!(elem.type || elem.href || ~elem.tabIndex); + }, + + // Boolean properties + "enabled" : function(elem) { + return elem.disabled === false; + }, + + "disabled" : function(elem) { + return elem.disabled === true; + }, + + "checked" : function(elem) { + // In CSS3, :checked should return both + // checked and selected elements + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + var nodeName = elem.nodeName.toLowerCase(); + return (nodeName === "input" && !!elem.checked) + || (nodeName === "option" && !!elem.selected); + }, + + "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; + }, + + // Contents + "empty" : function(elem) { + // http://www.w3.org/TR/selectors/#empty-pseudo + // :empty is negated by element (1) or + // content nodes (text: 3; cdata: 4; entity + // ref: 5), + // but not by others (comment: 8; processing + // instruction: 7; etc.) + // nodeType < 6 works because attributes (2) + // do not appear as children + for (elem = elem.firstChild; elem; elem = elem.nextSibling) { + if (elem.nodeType < 6) { + return false; + } + } + return true; + }, + + "parent" : function(elem) { + return !Expr.pseudos["empty"](elem); + }, + + // Element/input types + "header" : function(elem) { + return rheader.test(elem.nodeName); + }, + + "input" : function(elem) { + return rinputs.test(elem.nodeName); + }, + + "button" : function(elem) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && elem.type === "button" || name === "button"; + }, + + "text" : function(elem) { + var attr; + return elem.nodeName.toLowerCase() === "input" && elem.type === "text" && + + // Support: IE<8 + // New HTML5 attribute values (e.g., + // "search") appear with elem.type + // === "text" + ((attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text"); + }, + + // Position-in-collection + "first" : createPositionalPseudo(function() { + return [ 0 ]; + }), + + "last" : createPositionalPseudo(function(matchIndexes, length) { + return [ length - 1 ]; + }), + + "eq" : createPositionalPseudo(function(matchIndexes, length, argument) { + return [ argument < 0 ? argument + length : argument ]; + }), + + "even" : createPositionalPseudo(function(matchIndexes, length) { + var i = 0; + for (; i < length; i += 2) { + matchIndexes.push(i); + } + return matchIndexes; + }), + + "odd" : createPositionalPseudo(function(matchIndexes, length) { + var i = 1; + for (; i < length; i += 2) { + matchIndexes.push(i); + } + return matchIndexes; + }), + + "lt" : createPositionalPseudo(function(matchIndexes, length, argument) { + var i = argument < 0 ? argument + length : argument; + for (; --i >= 0;) { + matchIndexes.push(i); + } + return matchIndexes; + }), + + "gt" : createPositionalPseudo(function(matchIndexes, length, argument) { + var i = argument < 0 ? argument + length : argument; + for (; ++i < length;) { + matchIndexes.push(i); + } + return matchIndexes; + }) + } + }; + + Expr.pseudos["nth"] = Expr.pseudos["eq"]; + + // Add button/input type pseudos + for (i in { + radio : true, + checkbox : true, + file : true, + password : true, + image : true + }) { + Expr.pseudos[i] = createInputPseudo(i); + } + for (i in { + submit : true, + reset : true + }) { + Expr.pseudos[i] = createButtonPseudo(i); + } + + // Easy API for creating new setFilters + function setFilters() { + } + setFilters.prototype = Expr.filters = Expr.pseudos; + Expr.setFilters = new setFilters(); + + tokenize = Sizzle.tokenize = function(selector, parseOnly) { + var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[selector + + " "]; + + if (cached) { + return parseOnly ? 0 : cached.slice(0); + } + + soFar = selector; + groups = []; + preFilters = Expr.preFilter; + + while (soFar) { + + // Comma and first run + if (!matched || (match = rcomma.exec(soFar))) { + if (match) { + // Don't consume trailing commas as + // valid + soFar = soFar.slice(match[0].length) || soFar; + } + groups.push((tokens = [])); + } + + matched = false; + + // Combinators + if ((match = rcombinators.exec(soFar))) { + matched = match.shift(); + tokens.push({ + value : matched, + // Cast descendant combinators to space + type : match[0].replace(rtrim, " ") + }); + soFar = soFar.slice(matched.length); + } + + // Filters + for (type in Expr.filter) { + if ((match = matchExpr[type].exec(soFar)) + && (!preFilters[type] || (match = preFilters[type](match)))) { + matched = match.shift(); + tokens.push({ + value : matched, + type : type, + matches : match + }); + soFar = soFar.slice(matched.length); + } + } + + if (!matched) { + break; + } + } + + // Return the length of the invalid excess + // if we're just parsing + // Otherwise, throw an error or return tokens + return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) : + // Cache the tokens + tokenCache(selector, groups).slice(0); + }; + + function toSelector(tokens) { + var i = 0, len = tokens.length, selector = ""; + for (; i < len; i++) { + selector += tokens[i].value; + } + return selector; + } + + function addCombinator(matcher, combinator, base) { + var dir = combinator.dir, checkNonElements = base && dir === "parentNode", doneName = done++; + + return combinator.first ? + // Check against closest ancestor/preceding element + function(elem, context, xml) { + while ((elem = elem[dir])) { + if (elem.nodeType === 1 || checkNonElements) { + return matcher(elem, context, xml); + } + } + } + : + + // Check against all ancestor/preceding + // elements + function(elem, context, xml) { + var oldCache, uniqueCache, outerCache, newCache = [ dirruns, doneName ]; + + // We can't set arbitrary data on XML + // nodes, so they don't benefit from + // combinator caching + if (xml) { + while ((elem = elem[dir])) { + if (elem.nodeType === 1 || checkNonElements) { + if (matcher(elem, context, xml)) { + return true; + } + } + } + } else { + while ((elem = elem[dir])) { + if (elem.nodeType === 1 || checkNonElements) { + outerCache = elem[expando] || (elem[expando] = {}); + + // Support: IE <9 only + // Defend against cloned + // attroperties (jQuery + // gh-1709) + uniqueCache = outerCache[elem.uniqueID] + || (outerCache[elem.uniqueID] = {}); + + if ((oldCache = uniqueCache[dir]) && oldCache[0] === dirruns + && oldCache[1] === doneName) { + + // Assign to newCache so + // results + // back-propagate to + // previous elements + return (newCache[2] = oldCache[2]); + } else { + // Reuse newcache so + // results + // back-propagate to + // previous elements + uniqueCache[dir] = newCache; + + // A match means we're + // done; a fail means we + // have to keep checking + if ((newCache[2] = matcher(elem, context, xml))) { + return true; + } + } + } + } + } + }; + } + + function elementMatcher(matchers) { + return matchers.length > 1 ? function(elem, context, xml) { + var i = matchers.length; + while (i--) { + if (!matchers[i](elem, context, xml)) { + return false; + } + } + return true; + } : matchers[0]; + } + + function multipleContexts(selector, contexts, results) { + var i = 0, len = contexts.length; + for (; i < len; i++) { + Sizzle(selector, contexts[i], results); + } + return results; + } + + function condense(unmatched, map, filter, context, xml) { + var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = map != null; + + for (; i < len; i++) { + if ((elem = unmatched[i])) { + if (!filter || filter(elem, context, xml)) { + newUnmatched.push(elem); + if (mapped) { + map.push(i); + } + } + } + } + + return newUnmatched; + } + + function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) { + if (postFilter && !postFilter[expando]) { + postFilter = setMatcher(postFilter); + } + if (postFinder && !postFinder[expando]) { + postFinder = setMatcher(postFinder, postSelector); + } + return markFunction(function(seed, results, context, xml) { + var temp, i, elem, preMap = [], postMap = [], preexisting = results.length, + + // Get initial elements from seed or context + elems = seed + || multipleContexts(selector || "*", context.nodeType ? [ context ] : context, + []), + + // Prefilter to get matcher input, preserving a + // map for seed-results synchronization + matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, + context, xml) : elems, + + matcherOut = matcher ? + // If we have a postFinder, or filtered seed, or + // non-seed postFilter or preexisting results, + postFinder || (seed ? preFilter : preexisting || postFilter) ? + + // ...intermediate processing is necessary + [] : + + // ...otherwise use results directly + results : matcherIn; + + // Find primary matches + if (matcher) { + matcher(matcherIn, matcherOut, context, xml); + } + + // Apply postFilter + if (postFilter) { + temp = condense(matcherOut, postMap); + postFilter(temp, [], context, xml); + + // Un-match failing elements by moving them + // back to matcherIn + i = temp.length; + while (i--) { + if ((elem = temp[i])) { + matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem); + } + } + } + + if (seed) { + if (postFinder || preFilter) { + if (postFinder) { + // Get the final matcherOut by + // condensing this intermediate into + // postFinder contexts + temp = []; + i = matcherOut.length; + while (i--) { + if ((elem = matcherOut[i])) { + // Restore matcherIn since + // elem is not yet a final + // match + temp.push((matcherIn[i] = elem)); + } + } + postFinder(null, (matcherOut = []), temp, xml); + } + + // Move matched elements from seed to + // results to keep them synchronized + i = matcherOut.length; + while (i--) { + if ((elem = matcherOut[i]) + && (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) { + + seed[temp] = !(results[temp] = elem); + } + } + } + + // Add elements to results, through + // postFinder if defined + } else { + matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, + matcherOut.length) : matcherOut); + if (postFinder) { + postFinder(null, results, matcherOut, xml); + } else { + push.apply(results, matcherOut); + } + } + }); + } + + function matcherFromTokens(tokens) { + var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[tokens[0].type], implicitRelative = leadingRelative + || Expr.relative[" "], i = leadingRelative ? 1 : 0, + + // The foundational matcher ensures that elements + // are reachable from top-level context(s) + matchContext = addCombinator(function(elem) { + return elem === checkContext; + }, implicitRelative, true), matchAnyContext = addCombinator(function(elem) { + return indexOf(checkContext, elem) > -1; + }, implicitRelative, true), matchers = [ function(elem, context, xml) { + var ret = (!leadingRelative && (xml || context !== outermostContext)) + || ((checkContext = context).nodeType ? matchContext(elem, context, xml) + : matchAnyContext(elem, context, xml)); + // Avoid hanging onto element (issue #299) + checkContext = null; + return ret; + } ]; + + for (; i < len; i++) { + if ((matcher = Expr.relative[tokens[i].type])) { + matchers = [ addCombinator(elementMatcher(matchers), matcher) ]; + } else { + matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches); + + // Return special upon seeing a positional + // matcher + if (matcher[expando]) { + // Find the next relative operator (if + // any) for proper handling + j = ++i; + for (; j < len; j++) { + if (Expr.relative[tokens[j].type]) { + break; + } + } + return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector( + // If the + // preceding + // token was a + // descendant + // combinator, + // insert an + // implicit + // any-element + // `*` + tokens.slice(0, i - 1).concat({ + value : tokens[i - 2].type === " " ? "*" : "" + })).replace(rtrim, "$1"), matcher, i < j + && matcherFromTokens(tokens.slice(i, j)), j < len + && matcherFromTokens((tokens = tokens.slice(j))), j < len + && toSelector(tokens)); + } + matchers.push(matcher); + } + } + + return elementMatcher(matchers); + } + + function matcherFromGroupMatchers(elementMatchers, setMatchers) { + var bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function( + seed, context, xml, results, outermost) { + var elem, j, matcher, matchedCount = 0, i = "0", unmatched = seed && [], setMatched = [], contextBackup = outermostContext, + // We must always have either seed elements or + // outermost context + elems = seed || byElement && Expr.find["TAG"]("*", outermost), + // Use integer dirruns iff this is the outermost + // matcher + dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1), len = elems.length; + + if (outermost) { + outermostContext = context === document || context || outermost; + } + + // Add elements passing elementMatchers directly + // to results + // Support: IE<9, Safari + // Tolerate NodeList properties (IE: "length"; + // Safari: <number>) matching elements by id + for (; i !== len && (elem = elems[i]) != null; i++) { + if (byElement && elem) { + j = 0; + if (!context && elem.ownerDocument !== document) { + setDocument(elem); + xml = !documentIsHTML; + } + while ((matcher = elementMatchers[j++])) { + if (matcher(elem, context || document, xml)) { + results.push(elem); + break; + } + } + if (outermost) { + dirruns = dirrunsUnique; + } + } + + // Track unmatched elements for set filters + if (bySet) { + // They will have gone through all + // possible matchers + if ((elem = !matcher && elem)) { + matchedCount--; + } + + // Lengthen the array for every element, + // matched or not + if (seed) { + unmatched.push(elem); + } + } + } + + // `i` is now the count of elements visited + // above, and adding it to `matchedCount` + // makes the latter nonnegative. + matchedCount += i; + + // Apply set filters to unmatched elements + // NOTE: This can be skipped if there are no + // unmatched elements (i.e., `matchedCount` + // equals `i`), unless we didn't visit _any_ + // elements in the above loop because we have + // no element matchers and no seed. + // Incrementing an initially-string "0" `i` + // allows `i` to remain a string only in that + // case, which will result in a "00" + // `matchedCount` that differs from `i` but is + // also + // numerically zero. + if (bySet && i !== matchedCount) { + j = 0; + while ((matcher = setMatchers[j++])) { + matcher(unmatched, setMatched, context, xml); + } + + if (seed) { + // Reintegrate element matches to + // eliminate the need for sorting + if (matchedCount > 0) { + while (i--) { + if (!(unmatched[i] || setMatched[i])) { + setMatched[i] = pop.call(results); + } + } + } + + // Discard index placeholder values to + // get only actual matches + setMatched = condense(setMatched); + } + + // Add matches to results + push.apply(results, setMatched); + + // Seedless set matches succeeding multiple + // successful matchers stipulate sorting + if (outermost && !seed && setMatched.length > 0 + && (matchedCount + setMatchers.length) > 1) { + + Sizzle.uniqueSort(results); + } + } + + // Override manipulation of globals by nested + // matchers + if (outermost) { + dirruns = dirrunsUnique; + outermostContext = contextBackup; + } + + return unmatched; + }; + + return bySet ? markFunction(superMatcher) : superMatcher; + } + + compile = Sizzle.compile = function(selector, match /* + * Internal + * Use + * Only + */) { + var i, setMatchers = [], elementMatchers = [], cached = compilerCache[selector + " "]; + + if (!cached) { + // Generate a function of recursive functions + // that can be used to check each element + if (!match) { + match = tokenize(selector); + } + i = match.length; + while (i--) { + cached = matcherFromTokens(match[i]); + if (cached[expando]) { + setMatchers.push(cached); + } else { + elementMatchers.push(cached); + } + } + + // Cache the compiled function + cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers)); + + // Save selector and tokenization + cached.selector = selector; + } + return cached; + }; + + /** + * A low-level selection function that works with + * Sizzle's compiled selector functions + * + * @param {String|Function} + * selector A selector or a pre-compiled + * selector function built with + * Sizzle.compile + * @param {Element} + * context + * @param {Array} + * [results] + * @param {Array} + * [seed] A set of elements to match against + */ + select = Sizzle.select = function(selector, context, results, seed) { + var i, tokens, token, type, find, compiled = typeof selector === "function" && selector, match = !seed + && tokenize((selector = compiled.selector || selector)); + + results = results || []; + + // Try to minimize operations if there is only one + // selector in the list and no seed + // (the latter of which guarantees us context) + if (match.length === 1) { + + // Reduce context if the leading compound + // selector is an ID + tokens = match[0] = match[0].slice(0); + if (tokens.length > 2 && (token = tokens[0]).type === "ID" && support.getById + && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) { + + context = (Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [])[0]; + if (!context) { + return results; + + // Precompiled matchers will still + // verify ancestry, so step up a level + } else if (compiled) { + context = context.parentNode; + } + + selector = selector.slice(tokens.shift().value.length); + } + + // Fetch a seed set for right-to-left matching + i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length; + while (i--) { + token = tokens[i]; + + // Abort if we hit a combinator + if (Expr.relative[(type = token.type)]) { + break; + } + if ((find = Expr.find[type])) { + // Search, expanding context for leading + // sibling combinators + if ((seed = find(token.matches[0].replace(runescape, funescape), rsibling + .test(tokens[0].type) + && testContext(context.parentNode) || context))) { + + // If seed is empty or no tokens + // remain, we can return early + tokens.splice(i, 1); + selector = seed.length && toSelector(tokens); + if (!selector) { + push.apply(results, seed); + return results; + } + + break; + } + } + } + } + + // Compile and execute a filtering function if one + // is not provided + // Provide `match` to avoid retokenization if we + // modified the selector above + (compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context + || rsibling.test(selector) && testContext(context.parentNode) || context); + return results; + }; + + // One-time assignments + + // Sort stability + support.sortStable = expando.split("").sort(sortOrder).join("") === expando; + + // Support: Chrome 14-35+ + // Always assume duplicates if they aren't passed to the + // comparison function + support.detectDuplicates = !!hasDuplicate; + + // Initialize against the default document + setDocument(); + + // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 + // (fixed in Chrome 27) + // Detached nodes confoundingly follow *each other* + support.sortDetached = assert(function(div1) { + // Should return 1, but returns 4 (following) + return div1.compareDocumentPosition(document.createElement("div")) & 1; + }); + + // Support: IE<8 + // Prevent attribute/property "interpolation" + // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx + if (!assert(function(div) { + div.innerHTML = "<a href='#'></a>"; + return div.firstChild.getAttribute("href") === "#"; + })) { + addHandle("type|href|height|width", function(elem, name, isXML) { + if (!isXML) { + return elem.getAttribute(name, name.toLowerCase() === "type" ? 1 : 2); + } + }); + } + + // Support: IE<9 + // Use defaultValue in place of getAttribute("value") + if (!support.attributes || !assert(function(div) { + div.innerHTML = "<input/>"; + div.firstChild.setAttribute("value", ""); + return div.firstChild.getAttribute("value") === ""; + })) { + addHandle("value", function(elem, name, isXML) { + if (!isXML && elem.nodeName.toLowerCase() === "input") { + return elem.defaultValue; + } + }); + } + + // Support: IE<9 + // Use getAttributeNode to fetch booleans when + // getAttribute lies + if (!assert(function(div) { + return div.getAttribute("disabled") == null; + })) { + addHandle(booleans, function(elem, name, isXML) { + var val; + if (!isXML) { + return elem[name] === true ? name.toLowerCase() : (val = elem + .getAttributeNode(name)) + && val.specified ? val.value : null; + } + }); + } + + return Sizzle; + + })(window); + + jQuery.find = Sizzle; + jQuery.expr = Sizzle.selectors; + jQuery.expr[":"] = jQuery.expr.pseudos; + jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; + jQuery.text = Sizzle.getText; + jQuery.isXMLDoc = Sizzle.isXML; + jQuery.contains = Sizzle.contains; + + var dir = function(elem, dir, until) { + var matched = [], truncate = until !== undefined; + + while ((elem = elem[dir]) && elem.nodeType !== 9) { + if (elem.nodeType === 1) { + if (truncate && jQuery(elem).is(until)) { + break; + } + matched.push(elem); + } + } + return matched; + }; + + var siblings = function(n, elem) { + var matched = []; + + for (; n; n = n.nextSibling) { + if (n.nodeType === 1 && n !== elem) { + matched.push(n); + } + } + + return matched; + }; + + var rneedsContext = jQuery.expr.match.needsContext; + + var rsingleTag = (/^<([\w-]+)\s*\/?>(?:<\/\1>|)$/); + + var risSimple = /^.[^:#\[\.,]*$/; + + // Implement the identical functionality for filter and not + function winnow(elements, qualifier, not) { + if (jQuery.isFunction(qualifier)) { + return jQuery.grep(elements, function(elem, i) { + /* jshint -W018 */ + return !!qualifier.call(elem, i, elem) !== not; + }); + + } + + if (qualifier.nodeType) { + return jQuery.grep(elements, function(elem) { + return (elem === qualifier) !== not; + }); + + } + + if (typeof qualifier === "string") { + if (risSimple.test(qualifier)) { + return jQuery.filter(qualifier, elements, not); + } + + qualifier = jQuery.filter(qualifier, elements); + } + + return jQuery.grep(elements, function(elem) { + return (jQuery.inArray(elem, qualifier) > -1) !== not; + }); + } + + jQuery.filter = function(expr, elems, not) { + var elem = elems[0]; + + if (not) { + expr = ":not(" + expr + ")"; + } + + return elems.length === 1 && elem.nodeType === 1 ? jQuery.find.matchesSelector(elem, expr) ? [ elem ] + : [] + : jQuery.find.matches(expr, jQuery.grep(elems, function(elem) { + return elem.nodeType === 1; + })); + }; + + jQuery.fn.extend({ + find : function(selector) { + var i, ret = [], self = this, len = self.length; + + if (typeof selector !== "string") { + return this.pushStack(jQuery(selector).filter(function() { + for (i = 0; i < len; i++) { + if (jQuery.contains(self[i], this)) { + return true; + } + } + })); + } + + for (i = 0; i < len; i++) { + jQuery.find(selector, self[i], ret); + } + + // Needed because $( selector, context ) + // becomes $( context ).find( selector ) + ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret); + ret.selector = this.selector ? this.selector + " " + selector : selector; + return ret; + }, + filter : function(selector) { + return this.pushStack(winnow(this, selector || [], false)); + }, + not : function(selector) { + return this.pushStack(winnow(this, selector || [], true)); + }, + is : function(selector) { + return !!winnow(this, + + // If this is a positional/relative + // selector, check membership in the + // returned set + // so $("p:first").is("p:last") + // won't return true for a doc with + // two "p". + typeof selector === "string" && rneedsContext.test(selector) ? jQuery(selector) : selector + || [], false).length; + } + }); + + // Initialize a jQuery object + + // A central reference to the root jQuery(document) + var rootjQuery, + + // A simple way to check for HTML strings + // Prioritize #id over <tag> to avoid XSS via location.hash + // (#9521) + // Strict HTML recognition (#11290: must start with <) + rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/, + + init = jQuery.fn.init = function(selector, context, root) { + var match, elem; + + // HANDLE: $(""), $(null), $(undefined), $(false) + if (!selector) { + return this; + } + + // init accepts an alternate rootjQuery + // so migrate can support jQuery.sub (gh-2101) + root = root || rootjQuery; + + // Handle HTML strings + if (typeof selector === "string") { + 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 = rquickExpr.exec(selector); + } + + // Match html or make sure no context is specified + // for #id + if (match && (match[1] || !context)) { + + // HANDLE: $(html) -> $(array) + if (match[1]) { + context = context instanceof jQuery ? context[0] : context; + + // scripts is true for back-compat + // Intentionally let the error be thrown if + // parseHTML is not present + jQuery.merge(this, jQuery.parseHTML(match[1], + context && context.nodeType ? context.ownerDocument || context : document, + true)); + + // HANDLE: $(html, props) + if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) { + for (match in context) { + + // Properties of context are called + // as methods if possible + if (jQuery.isFunction(this[match])) { + this[match](context[match]); + + // ...and otherwise set as + // attributes + } else { + this.attr(match, context[match]); + } + } + } + + return this; + + // 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 || root).find(selector); + + // HANDLE: $(expr, context) + // (which is just equivalent to: + // $(context).find(expr) + } else { + return this.constructor(context).find(selector); + } + + // HANDLE: $(DOMElement) + } else if (selector.nodeType) { + this.context = this[0] = selector; + this.length = 1; + return this; + + // HANDLE: $(function) + // Shortcut for document ready + } else if (jQuery.isFunction(selector)) { + return typeof root.ready !== "undefined" ? root.ready(selector) : + + // Execute immediately if ready is not present + selector(jQuery); + } + + if (selector.selector !== undefined) { + this.selector = selector.selector; + this.context = selector.context; + } + + return jQuery.makeArray(selector, this); + }; + + // Give the init function the jQuery prototype for later + // instantiation + init.prototype = jQuery.fn; + + // Initialize central reference + rootjQuery = jQuery(document); + + var rparentsprev = /^(?:parents|prev(?:Until|All))/, + + // 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({ + has : function(target) { + var i, targets = jQuery(target, this), len = targets.length; + + return this.filter(function() { + for (i = 0; i < len; i++) { + if (jQuery.contains(this, targets[i])) { + return true; + } + } + }); + }, + + closest : function(selectors, context) { + var cur, i = 0, l = this.length, matched = [], pos = rneedsContext.test(selectors) + || typeof selectors !== "string" ? jQuery(selectors, context || this.context) : 0; + + for (; i < l; i++) { + for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) { + + // Always skip document fragments + if (cur.nodeType < 11 && (pos ? pos.index(cur) > -1 : + + // Don't pass + // non-elements to + // Sizzle + cur.nodeType === 1 && jQuery.find.matchesSelector(cur, selectors))) { + + matched.push(cur); + break; + } + } + } + + return this.pushStack(matched.length > 1 ? jQuery.uniqueSort(matched) : matched); + }, + + // 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.first().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) { + return this.pushStack(jQuery + .uniqueSort(jQuery.merge(this.get(), jQuery(selector, context)))); + }, + + addBack : function(selector) { + return this.add(selector == null ? this.prevObject : this.prevObject.filter(selector)); + } + }); + + function sibling(cur, dir) { + do { + cur = cur[dir]; + } while (cur && cur.nodeType !== 1); + + return cur; + } + + jQuery.each({ + parent : function(elem) { + var parent = elem.parentNode; + return parent && parent.nodeType !== 11 ? parent : null; + }, + parents : function(elem) { + return dir(elem, "parentNode"); + }, + parentsUntil : function(elem, i, until) { + return dir(elem, "parentNode", until); + }, + next : function(elem) { + return sibling(elem, "nextSibling"); + }, + prev : function(elem) { + return sibling(elem, "previousSibling"); + }, + nextAll : function(elem) { + return dir(elem, "nextSibling"); + }, + prevAll : function(elem) { + return dir(elem, "previousSibling"); + }, + nextUntil : function(elem, i, until) { + return dir(elem, "nextSibling", until); + }, + prevUntil : function(elem, i, until) { + return dir(elem, "previousSibling", until); + }, + siblings : function(elem) { + return siblings((elem.parentNode || {}).firstChild, elem); + }, + children : function(elem) { + return siblings(elem.firstChild); + }, + contents : function(elem) { + return jQuery.nodeName(elem, "iframe") ? elem.contentDocument + || elem.contentWindow.document : jQuery.merge([], elem.childNodes); + } + }, function(name, fn) { + jQuery.fn[name] = function(until, selector) { + var ret = jQuery.map(this, fn, until); + + if (name.slice(-5) !== "Until") { + selector = until; + } + + if (selector && typeof selector === "string") { + ret = jQuery.filter(selector, ret); + } + + if (this.length > 1) { + + // Remove duplicates + if (!guaranteedUnique[name]) { + ret = jQuery.uniqueSort(ret); + } + + // Reverse order for parents* + // and prev-derivatives + if (rparentsprev.test(name)) { + ret = ret.reverse(); + } + } + + return this.pushStack(ret); + }; + }); + var rnotwhite = (/\S+/g); + + // Convert String-formatted options into Object-formatted + // ones + function createOptions(options) { + var object = {}; + jQuery.each(options.match(rnotwhite) || [], function(_, flag) { + object[flag] = true; + }); + return object; + } + + /* + * Create a callback list using the following parameters: + * + * options: an optional list of space-separated options that + * will change how the callback list behaves or a more + * traditional option object + * + * By default a callback list will act like an event + * callback list and can be "fired" multiple times. + * + * Possible options: + * + * 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(options) { + + // Convert options from String-formatted to + // Object-formatted if needed + // (we check in cache first) + options = typeof options === "string" ? createOptions(options) : jQuery.extend({}, options); + + var // Flag to know if list is currently firing + firing, + + // Last fire value for non-forgettable lists + memory, + + // Flag to know if list was already fired + fired, + + // Flag to prevent firing + locked, + + // Actual callback list + list = [], + + // Queue of execution data for repeatable lists + queue = [], + + // Index of currently firing callback (modified by + // add/remove as needed) + firingIndex = -1, + + // Fire callbacks + fire = function() { + + // Enforce single-firing + locked = options.once; + + // Execute callbacks for all pending executions, + // respecting firingIndex overrides and runtime + // changes + fired = firing = true; + for (; queue.length; firingIndex = -1) { + memory = queue.shift(); + while (++firingIndex < list.length) { + + // Run callback and check for early + // termination + if (list[firingIndex].apply(memory[0], memory[1]) === false && options.stopOnFalse) { + + // Jump to end and forget the data so + // .add doesn't re-fire + firingIndex = list.length; + memory = false; + } + } + } + + // Forget the data if we're done with it + if (!options.memory) { + memory = false; + } + + firing = false; + + // Clean up if we're done firing for good + if (locked) { + + // Keep an empty list if we have data for future + // add calls + if (memory) { + list = []; + + // Otherwise, this object is spent + } else { + list = ""; + } + } + }, + + // Actual Callbacks object + self = { + + // Add a callback or a collection of callbacks to + // the list + add : function() { + if (list) { + + // If we have memory from a past run, we + // should fire after adding + if (memory && !firing) { + firingIndex = list.length - 1; + queue.push(memory); + } + + (function add(args) { + jQuery.each(args, function(_, arg) { + if (jQuery.isFunction(arg)) { + if (!options.unique || !self.has(arg)) { + list.push(arg); + } + } else if (arg && arg.length && jQuery.type(arg) !== "string") { + + // Inspect + // recursively + add(arg); + } + }); + })(arguments); + + if (memory && !firing) { + fire(); + } + } + return this; + }, + + // Remove a callback from the list + remove : function() { + jQuery.each(arguments, function(_, arg) { + var index; + while ((index = jQuery.inArray(arg, list, index)) > -1) { + list.splice(index, 1); + + // Handle firing indexes + if (index <= firingIndex) { + firingIndex--; + } + } + }); + return this; + }, + + // Check if a given callback is in the list. + // If no argument is given, return whether or not + // list has callbacks attached. + has : function(fn) { + return fn ? jQuery.inArray(fn, list) > -1 : list.length > 0; + }, + + // Remove all callbacks from the list + empty : function() { + if (list) { + list = []; + } + return this; + }, + + // Disable .fire and .add + // Abort any current/pending executions + // Clear all callbacks and values + disable : function() { + locked = queue = []; + list = memory = ""; + return this; + }, + disabled : function() { + return !list; + }, + + // Disable .fire + // Also disable .add unless we have memory (since it + // would have no effect) + // Abort any pending executions + lock : function() { + locked = true; + if (!memory) { + self.disable(); + } + return this; + }, + locked : function() { + return !!locked; + }, + + // Call all callbacks with the given context and + // arguments + fireWith : function(context, args) { + if (!locked) { + args = args || []; + args = [ context, args.slice ? args.slice() : args ]; + queue.push(args); + if (!firing) { + fire(); + } + } + 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; + }; + + jQuery + .extend({ + + Deferred : function(func) { + var tuples = [ + + // action, add listener, listener + // list, final state + [ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ], + [ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ], + [ "notify", "progress", jQuery.Callbacks("memory") ] ], state = "pending", promise = { + state : function() { + return state; + }, + always : function() { + deferred.done(arguments).fail(arguments); + return this; + }, + then : function( /* + * fnDone, fnFail, + * fnProgress + */) { + var fns = arguments; + return jQuery.Deferred( + function(newDefer) { + jQuery.each(tuples, function(i, tuple) { + var fn = jQuery.isFunction(fns[i]) && fns[i]; + + // deferred[ + // done + // | + // fail + // | + // progress + // ] + // for + // forwarding + // actions + // to + // newDefer + deferred[tuple[1]](function() { + var returned = fn && fn.apply(this, arguments); + if (returned && jQuery.isFunction(returned.promise)) { + returned.promise().progress(newDefer.notify).done( + newDefer.resolve).fail(newDefer.reject); + } else { + newDefer[tuple[0] + "With"]( + this === promise ? newDefer.promise() + : this, fn ? [ returned ] + : arguments); + } + }); + }); + fns = null; + }).promise(); + }, + + // Get a promise for this deferred + // If obj is provided, the promise + // aspect is added to the object + promise : function(obj) { + return obj != null ? jQuery.extend(obj, promise) : promise; + } + }, deferred = {}; + + // Keep pipe for back-compat + promise.pipe = promise.then; + + // Add list-specific methods + jQuery.each(tuples, function(i, tuple) { + var list = tuple[2], stateString = tuple[3]; + + // promise[ done | fail + // | progress ] = + // list.add + promise[tuple[1]] = list.add; + + // Handle state + if (stateString) { + list.add(function() { + + // state + // = [ + // resolved + // | + // rejected + // ] + state = stateString; + + // [ + // reject_list + // | + // resolve_list + // ].disable; + // progress_list.lock + }, tuples[i ^ 1][2].disable, tuples[2][2].lock); + } + + // deferred[ resolve | + // reject | notify ] + deferred[tuple[0]] = function() { + deferred[tuple[0] + "With"](this === deferred ? promise : this, arguments); + return this; + }; + deferred[tuple[0] + "With"] = list.fireWith; + }); + + // Make the deferred a promise + promise.promise(deferred); + + // Call given func if any + if (func) { + func.call(deferred, deferred); + } + + // All done! + return deferred; + }, + + // Deferred helper + when : function(subordinate /* + * , ..., + * subordinateN + */) { + var i = 0, resolveValues = slice.call(arguments), length = resolveValues.length, + + // the count of uncompleted subordinates + remaining = length !== 1 || (subordinate && jQuery.isFunction(subordinate.promise)) ? length + : 0, + + // the master Deferred. + // If resolveValues consist of only a single + // Deferred, just use that. + deferred = remaining === 1 ? subordinate : jQuery.Deferred(), + + // Update function for both resolve and + // progress values + updateFunc = function(i, contexts, values) { + return function(value) { + contexts[i] = this; + values[i] = arguments.length > 1 ? slice.call(arguments) : value; + if (values === progressValues) { + deferred.notifyWith(contexts, values); + + } else if (!(--remaining)) { + deferred.resolveWith(contexts, values); + } + }; + }, + + progressValues, progressContexts, resolveContexts; + + // add listeners to Deferred subordinates; + // treat others as resolved + if (length > 1) { + progressValues = new Array(length); + progressContexts = new Array(length); + resolveContexts = new Array(length); + for (; i < length; i++) { + if (resolveValues[i] && jQuery.isFunction(resolveValues[i].promise)) { + resolveValues[i].promise().progress( + updateFunc(i, progressContexts, progressValues)).done( + updateFunc(i, resolveContexts, resolveValues)).fail( + deferred.reject); + } else { + --remaining; + } + } + } + + // if we're not waiting on anything, resolve + // the master + if (!remaining) { + deferred.resolveWith(resolveContexts, resolveValues); + } + + return deferred.promise(); + } + }); + + // The deferred used on DOM ready + var readyList; + + jQuery.fn.ready = function(fn) { + + // Add the callback + jQuery.ready.promise().done(fn); + + return this; + }; + + jQuery.extend({ + + // 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) { + + // Abort if there are pending holds or we're already + // ready + if (wait === true ? --jQuery.readyWait : jQuery.isReady) { + return; + } + + // 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.resolveWith(document, [ jQuery ]); + + // Trigger any bound ready events + if (jQuery.fn.triggerHandler) { + jQuery(document).triggerHandler("ready"); + jQuery(document).off("ready"); + } + } + }); + + /** + * Clean-up method for dom ready events + */ + function detach() { + if (document.addEventListener) { + document.removeEventListener("DOMContentLoaded", completed); + window.removeEventListener("load", completed); + + } else { + document.detachEvent("onreadystatechange", completed); + window.detachEvent("onload", completed); + } + } + + /** + * The ready event handler and self cleanup method + */ + function completed() { + + // readyState === "complete" is good enough for us to + // call the dom ready in oldIE + if (document.addEventListener || window.event.type === "load" + || document.readyState === "complete") { + + detach(); + jQuery.ready(); + } + } + + jQuery.ready.promise = function(obj) { + if (!readyList) { + + readyList = jQuery.Deferred(); + + // Catch cases where $(document).ready() is called + // after the browser event has already occurred. + // Support: IE6-10 + // Older IE sometimes signals "interactive" too soon + if (document.readyState === "complete" + || (document.readyState !== "loading" && !document.documentElement.doScroll)) { + + // Handle it asynchronously to allow scripts the + // opportunity to delay ready + window.setTimeout(jQuery.ready); + + // Standards-based browsers support + // DOMContentLoaded + } else if (document.addEventListener) { + + // Use the handy event callback + document.addEventListener("DOMContentLoaded", completed); + + // A fallback to window.onload, that will always + // work + window.addEventListener("load", completed); + + // If IE event model is used + } else { + + // Ensure firing before onload, maybe late but + // safe also for iframes + document.attachEvent("onreadystatechange", completed); + + // A fallback to window.onload, that will always + // work + window.attachEvent("onload", completed); + + // If IE and not a frame + // continually check to see if the document is + // ready + var top = false; + + try { + top = window.frameElement == null && document.documentElement; + } catch (e) { + } + + if (top && top.doScroll) { + (function doScrollCheck() { + if (!jQuery.isReady) { + + try { + + // Use the trick by Diego Perini + // http://javascript.nwbox.com/IEContentLoaded/ + top.doScroll("left"); + } catch (e) { + return window.setTimeout(doScrollCheck, 50); + } + + // detach all dom ready events + detach(); + + // and execute any waiting functions + jQuery.ready(); + } + })(); + } + } + } + return readyList.promise(obj); + }; + + // Kick off the DOM ready check even if the user does not + jQuery.ready.promise(); + + // Support: IE<9 + // Iteration over object's inherited properties before its + // own + var i; + for (i in jQuery(support)) { + break; + } + support.ownFirst = i === "0"; + + // Note: most support tests are defined in their respective + // modules. + // false until the test is run + support.inlineBlockNeedsLayout = false; + + // Execute ASAP in case we need to set body.style.zoom + jQuery(function() { + + // Minified: var a,b,c,d + var val, div, body, container; + + body = document.getElementsByTagName("body")[0]; + if (!body || !body.style) { + + // Return for frameset docs that don't have a body + return; + } + + // Setup + div = document.createElement("div"); + container = document.createElement("div"); + container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px"; + body.appendChild(container).appendChild(div); + + if (typeof div.style.zoom !== "undefined") { + + // Support: IE<8 + // Check if natively block-level elements act like + // inline-block + // elements when setting their display to 'inline' + // and giving + // them layout + div.style.cssText = "display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1"; + + support.inlineBlockNeedsLayout = val = div.offsetWidth === 3; + if (val) { + + // Prevent IE 6 from affecting layout for + // positioned elements #11048 + // Prevent IE from shrinking the body in IE 7 + // mode #12869 + // Support: IE<8 + body.style.zoom = 1; + } + } + + body.removeChild(container); + }); + + (function() { + var div = document.createElement("div"); + + // Support: IE<9 + support.deleteExpando = true; + try { + delete div.test; + } catch (e) { + support.deleteExpando = false; + } + + // Null elements to avoid leaks in IE. + div = null; + })(); + var acceptData = function(elem) { + var noData = jQuery.noData[(elem.nodeName + " ").toLowerCase()], nodeType = +elem.nodeType || 1; + + // Do not set data on non-element DOM nodes because it + // will not be cleared (#8335). + return nodeType !== 1 && nodeType !== 9 ? false : + + // Nodes accept data unless otherwise specified; + // rejection can be conditional + !noData || noData !== true && elem.getAttribute("classid") === noData; + }; + + var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, rmultiDash = /([A-Z])/g; + + 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 : + + // Only convert to a + // number if it + // doesn't change + // the string + +data + "" === 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) { + var name; + for (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 internalData(elem, name, data, pvt /* + * Internal Use + * Only + */) { + if (!acceptData(elem)) { + return; + } + + var ret, thisCache, internalKey = jQuery.expando, + + // 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; + + // 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] || (!pvt && !cache[id].data)) && data === undefined + && typeof name === "string") { + 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) { + id = elem[internalKey] = deletedIds.pop() || jQuery.guid++; + } else { + id = internalKey; + } + } + + if (!cache[id]) { + + // Avoid exposing jQuery metadata on plain JS + // objects when the object + // is serialized using JSON.stringify + cache[id] = isNode ? {} : { + 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); + } + } + + 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; + } + + // Check for both converted-to-camel and non-converted + // data property names + // If a data property was specified + if (typeof name === "string") { + + // 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; + } + + function internalRemoveData(elem, name, pvt) { + if (!acceptData(elem)) { + return; + } + + var thisCache, i, isNode = elem.nodeType, + + // See jQuery.data for more information + cache = isNode ? jQuery.cache : elem, id = isNode ? elem[jQuery.expando] : jQuery.expando; + + // 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(" "); + } + } + } else { + + // If "name" is an array of keys... + // When data is initially created, via + // ("key", "val") signature, + // keys will be converted to camelCase. + // Since there is no way to tell _how_ a key + // was added, remove + // both plain key and camelCase key. #12786 + // This will only penalize the array + // argument path. + name = name.concat(jQuery.map(name, jQuery.camelCase)); + } + + i = name.length; + while (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(thisCache) : !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; + } + } + + // Destroy the cache + if (isNode) { + jQuery.cleanData([ elem ], true); + + // Use delete when supported for expandos or `cache` + // is not a window per isWindow (#10080) + /* jshint eqeqeq: false */ + } else if (support.deleteExpando || cache != cache.window) { + /* jshint eqeqeq: true */ + delete cache[id]; + + // When all else fails, undefined + } else { + cache[id] = undefined; + } + } + + jQuery.extend({ + cache : {}, + + // The following elements (space-suffixed to + // avoid Object.prototype collisions) + // throw uncatchable exceptions if you attempt + // to set expando properties + noData : { + "applet " : true, + "embed " : true, + + // ...but Flash objects (which have this + // classid) *can* handle expandos + "object " : "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" + }, + + hasData : function(elem) { + elem = elem.nodeType ? jQuery.cache[elem[jQuery.expando]] : elem[jQuery.expando]; + return !!elem && !isEmptyDataObject(elem); + }, + + data : function(elem, name, data) { + return internalData(elem, name, data); + }, + + removeData : function(elem, name) { + return internalRemoveData(elem, name); + }, + + // For internal use only. + _data : function(elem, name, data) { + return internalData(elem, name, data, true); + }, + + _removeData : function(elem, name) { + return internalRemoveData(elem, name, true); + } + }); + + jQuery.fn.extend({ + data : function(key, value) { + var i, name, data, elem = this[0], attrs = elem && elem.attributes; + + // Special expections of .data basically + // thwart jQuery.access, + // so implement the relevant behavior + // ourselves + + // Gets all values + if (key === undefined) { + if (this.length) { + data = jQuery.data(elem); + + if (elem.nodeType === 1 && !jQuery._data(elem, "parsedAttrs")) { + i = attrs.length; + while (i--) { + + // Support: IE11+ + // The attrs elements can be + // null (#14894) + if (attrs[i]) { + name = attrs[i].name; + if (name.indexOf("data-") === 0) { + name = jQuery.camelCase(name.slice(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); + }); + } + + return arguments.length > 1 ? + + // Sets one value + this.each(function() { + jQuery.data(this, key, value); + }) : + + // Gets one value + // Try to fetch any internally stored data + // first + elem ? dataAttr(elem, key, jQuery.data(elem, key)) : undefined; + }, + + removeData : function(key) { + return this.each(function() { + jQuery.removeData(this, key); + }); + } + }); + + jQuery + .extend({ + queue : function(elem, type, data) { + var queue; + + if (elem) { + type = (type || "fx") + "queue"; + queue = jQuery._data(elem, type); + + // Speed up dequeue by getting out + // quickly if this is just a lookup + if (data) { + if (!queue || jQuery.isArray(data)) { + queue = jQuery._data(elem, type, jQuery.makeArray(data)); + } else { + queue.push(data); + } + } + return queue || []; + } + }, + + dequeue : function(elem, type) { + type = type || "fx"; + + var queue = jQuery.queue(elem, type), startLength = queue.length, fn = queue + .shift(), hooks = jQuery._queueHooks(elem, type), next = function() { + jQuery.dequeue(elem, type); + }; + + // If the fx queue is dequeued, always + // remove the progress sentinel + if (fn === "inprogress") { + fn = queue.shift(); + startLength--; + } + + if (fn) { + + // Add a progress sentinel to prevent + // the fx queue from being + // automatically dequeued + if (type === "fx") { + queue.unshift("inprogress"); + } + + // clear up the last queue stop function + delete hooks.stop; + fn.call(elem, next, hooks); + } + + if (!startLength && hooks) { + hooks.empty.fire(); + } + }, + + // not intended for public consumption - + // generates a queueHooks object, + // or returns the current one + _queueHooks : function(elem, type) { + var key = type + "queueHooks"; + return jQuery._data(elem, key) || jQuery._data(elem, key, { + empty : jQuery.Callbacks("once memory").add(function() { + jQuery._removeData(elem, type + "queue"); + jQuery._removeData(elem, key); + }) + }); + } + }); + + 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); + + // ensure a hooks for + // this queue + jQuery._queueHooks(this, type); + + if (type === "fx" && queue[0] !== "inprogress") { + jQuery.dequeue(this, type); + } + }); + }, + dequeue : function(type) { + return this.each(function() { + jQuery.dequeue(this, type); + }); + }, + 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, obj) { + var tmp, count = 1, defer = jQuery.Deferred(), elements = this, i = this.length, resolve = function() { + if (!(--count)) { + defer.resolveWith(elements, [ elements ]); + } + }; + + if (typeof type !== "string") { + obj = type; + type = undefined; + } + type = type || "fx"; + + while (i--) { + tmp = jQuery._data(elements[i], type + "queueHooks"); + if (tmp && tmp.empty) { + count++; + tmp.empty.add(resolve); + } + } + resolve(); + return defer.promise(obj); + } + }); + + (function() { + var shrinkWrapBlocksVal; + + support.shrinkWrapBlocks = function() { + if (shrinkWrapBlocksVal != null) { + return shrinkWrapBlocksVal; + } + + // Will be changed later if needed. + shrinkWrapBlocksVal = false; + + // Minified: var b,c,d + var div, body, container; + + body = document.getElementsByTagName("body")[0]; + if (!body || !body.style) { + + // Test fired too early or in an unsupported + // environment, exit. + return; + } + + // Setup + div = document.createElement("div"); + container = document.createElement("div"); + container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px"; + body.appendChild(container).appendChild(div); + + // Support: IE6 + // Check if elements with layout shrink-wrap their + // children + if (typeof div.style.zoom !== "undefined") { + + // Reset CSS: box-sizing; display; margin; + // border + div.style.cssText = + + // Support: Firefox<29, Android 2.3 + // Vendor-prefix box-sizing + "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" + + "box-sizing:content-box;display:block;margin:0;border:0;" + + "padding:1px;width:1px;zoom:1"; + div.appendChild(document.createElement("div")).style.width = "5px"; + shrinkWrapBlocksVal = div.offsetWidth !== 3; + } + + body.removeChild(container); + + return shrinkWrapBlocksVal; + }; + + })(); + var pnum = (/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/).source; + + var rcssNum = new RegExp("^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i"); + + var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; + + var isHidden = function(elem, el) { + + // isHidden might be called from jQuery#filter function; + // in that case, element will be second argument + elem = el || elem; + return jQuery.css(elem, "display") === "none" || !jQuery.contains(elem.ownerDocument, elem); + }; + + function adjustCSS(elem, prop, valueParts, tween) { + var adjusted, scale = 1, maxIterations = 20, currentValue = tween ? function() { + return tween.cur(); + } : function() { + return jQuery.css(elem, prop, ""); + }, initial = currentValue(), unit = valueParts && valueParts[3] + || (jQuery.cssNumber[prop] ? "" : "px"), + + // Starting value computation is required for potential + // unit mismatches + initialInUnit = (jQuery.cssNumber[prop] || unit !== "px" && +initial) + && rcssNum.exec(jQuery.css(elem, prop)); + + if (initialInUnit && initialInUnit[3] !== unit) { + + // Trust units reported by jQuery.css + unit = unit || initialInUnit[3]; + + // Make sure we update the tween properties later on + valueParts = valueParts || []; + + // Iteratively approximate from a nonzero starting + // point + initialInUnit = +initial || 1; + + do { + + // If previous iteration zeroed out, double + // until we get *something*. + // Use string for doubling so we don't + // accidentally see scale as unchanged below + scale = scale || ".5"; + + // Adjust and apply + initialInUnit = initialInUnit / scale; + jQuery.style(elem, prop, initialInUnit + unit); + + // Update scale, tolerating zero or NaN from + // tween.cur() + // Break the loop if scale is unchanged or + // perfect, or if we've just had enough. + } while (scale !== (scale = currentValue() / initial) && scale !== 1 && --maxIterations); + } + + if (valueParts) { + initialInUnit = +initialInUnit || +initial || 0; + + // Apply relative offset (+=/-=) if specified + adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] + : +valueParts[2]; + if (tween) { + tween.unit = unit; + tween.start = initialInUnit; + tween.end = adjusted; + } + } + return adjusted; + } + + // Multifunctional method to get and set values of a + // collection + // The value/s can optionally be executed if it's a function + var access = function(elems, fn, key, value, chainable, emptyGet, raw) { + var i = 0, length = elems.length, bulk = key == null; + + // Sets many values + if (jQuery.type(key) === "object") { + chainable = true; + for (i in key) { + access(elems, fn, i, key[i], true, emptyGet, raw); + } + + // Sets one value + } else if (value !== undefined) { + chainable = true; + + if (!jQuery.isFunction(value)) { + raw = true; + } + + if (bulk) { + + // Bulk operations run against the entire set + if (raw) { + fn.call(elems, value); + fn = null; + + // ...except when executing function values + } else { + bulk = fn; + fn = function(elem, key, value) { + return bulk.call(jQuery(elem), value); + }; + } + } + + if (fn) { + for (; i < length; i++) { + fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key))); + } + } + } + + return chainable ? elems : + + // Gets + bulk ? fn.call(elems) : length ? fn(elems[0], key) : emptyGet; + }; + var rcheckableType = (/^(?:checkbox|radio)$/i); + + var rtagName = (/<([\w:-]+)/); + + var rscriptType = (/^$|\/(?:java|ecma)script/i); + + var rleadingWhitespace = (/^\s+/); + + var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|" + + "details|dialog|figcaption|figure|footer|header|hgroup|main|" + + "mark|meter|nav|output|picture|progress|section|summary|template|time|video"; + + function createSafeFragment(document) { + var list = nodeNames.split("|"), safeFrag = document.createDocumentFragment(); + + if (safeFrag.createElement) { + while (list.length) { + safeFrag.createElement(list.pop()); + } + } + return safeFrag; + } + + (function() { + var div = document.createElement("div"), fragment = document.createDocumentFragment(), input = document + .createElement("input"); + + // Setup + div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; + + // IE strips leading whitespace when .innerHTML is used + support.leadingWhitespace = div.firstChild.nodeType === 3; + + // Make sure that tbody elements aren't automatically + // inserted + // IE will insert them into empty tables + support.tbody = !div.getElementsByTagName("tbody").length; + + // Make sure that link elements get serialized correctly + // by innerHTML + // This requires a wrapper element in IE + support.htmlSerialize = !!div.getElementsByTagName("link").length; + + // Makes sure cloning an html5 element does not cause + // problems + // Where outerHTML is undefined, this still works + support.html5Clone = document.createElement("nav").cloneNode(true).outerHTML !== "<:nav></:nav>"; + + // Check if a disconnected checkbox will retain its + // checked + // value of true after appended to the DOM (IE6/7) + input.type = "checkbox"; + input.checked = true; + fragment.appendChild(input); + support.appendChecked = input.checked; + + // Make sure textarea (and checkbox) defaultValue is + // properly cloned + // Support: IE6-IE11+ + div.innerHTML = "<textarea>x</textarea>"; + support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue; + + // #11217 - WebKit loses check when the name is after + // the checked attribute + fragment.appendChild(div); + + // Support: Windows Web Apps (WWA) + // `name` and `type` must use .setAttribute for WWA + // (#14901) + input = document.createElement("input"); + input.setAttribute("type", "radio"); + input.setAttribute("checked", "checked"); + input.setAttribute("name", "t"); + + div.appendChild(input); + + // Support: Safari 5.1, iOS 5.1, Android 4.x, Android + // 2.3 + // old WebKit doesn't clone checked state correctly in + // fragments + support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked; + + // Support: IE<9 + // Cloned elements keep attachEvent handlers, we use + // addEventListener on IE9+ + support.noCloneEvent = !!div.addEventListener; + + // Support: IE<9 + // Since attributes and properties are the same in IE, + // cleanData must set properties to undefined rather + // than use removeAttribute + div[jQuery.expando] = 1; + support.attributes = !div.getAttribute(jQuery.expando); + })(); + + // We have to close these tags to support XHTML (#13200) + var wrapMap = { + option : [ 1, "<select multiple='multiple'>", "</select>" ], + legend : [ 1, "<fieldset>", "</fieldset>" ], + area : [ 1, "<map>", "</map>" ], + + // Support: IE8 + param : [ 1, "<object>", "</object>" ], + thead : [ 1, "<table>", "</table>" ], + tr : [ 2, "<table><tbody>", "</tbody></table>" ], + col : [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ], + td : [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ], + + // IE6-8 can't serialize link, script, style, or any + // html5 (NoScope) tags, + // unless wrapped in a div with non-breaking characters + // in front of it. + _default : support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>" ] + }; + + // Support: IE8-IE9 + wrapMap.optgroup = wrapMap.option; + + wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; + wrapMap.th = wrapMap.td; + + function getAll(context, tag) { + var elems, elem, i = 0, found = typeof context.getElementsByTagName !== "undefined" ? context + .getElementsByTagName(tag || "*") + : typeof context.querySelectorAll !== "undefined" ? context + .querySelectorAll(tag || "*") : undefined; + + if (!found) { + for (found = [], elems = context.childNodes || context; (elem = elems[i]) != null; i++) { + if (!tag || jQuery.nodeName(elem, tag)) { + found.push(elem); + } else { + jQuery.merge(found, getAll(elem, tag)); + } + } + } + + return tag === undefined || tag && jQuery.nodeName(context, tag) ? jQuery.merge([ context ], + found) : found; + } + + // Mark scripts as having already been evaluated + function setGlobalEval(elems, refElements) { + var elem, i = 0; + for (; (elem = elems[i]) != null; i++) { + jQuery + ._data(elem, "globalEval", !refElements + || jQuery._data(refElements[i], "globalEval")); + } + } + + var rhtml = /<|&#?\w+;/, rtbody = /<tbody/i; + + function fixDefaultChecked(elem) { + if (rcheckableType.test(elem.type)) { + elem.defaultChecked = elem.checked; + } + } + + function buildFragment(elems, context, scripts, selection, ignored) { + var j, elem, contains, tmp, tag, tbody, wrap, l = elems.length, + + // Ensure a safe fragment + safe = createSafeFragment(context), + + nodes = [], i = 0; + + for (; i < l; i++) { + elem = elems[i]; + + if (elem || elem === 0) { + + // Add nodes directly + if (jQuery.type(elem) === "object") { + jQuery.merge(nodes, elem.nodeType ? [ elem ] : elem); + + // Convert non-html into a text node + } else if (!rhtml.test(elem)) { + nodes.push(context.createTextNode(elem)); + + // Convert html into DOM nodes + } else { + tmp = tmp || safe.appendChild(context.createElement("div")); + + // Deserialize a standard representation + tag = (rtagName.exec(elem) || [ "", "" ])[1].toLowerCase(); + wrap = wrapMap[tag] || wrapMap._default; + + tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2]; + + // Descend through wrappers to the right + // content + j = wrap[0]; + while (j--) { + tmp = tmp.lastChild; + } + + // Manually add leading whitespace removed + // by IE + if (!support.leadingWhitespace && rleadingWhitespace.test(elem)) { + nodes.push(context.createTextNode(rleadingWhitespace.exec(elem)[0])); + } + + // Remove IE's autoinserted <tbody> from + // table fragments + if (!support.tbody) { + + // String was a <table>, *may* have + // spurious <tbody> + elem = tag === "table" && !rtbody.test(elem) ? tmp.firstChild : + + // String was a bare <thead> or + // <tfoot> + wrap[1] === "<table>" && !rtbody.test(elem) ? tmp : 0; + + j = elem && elem.childNodes.length; + while (j--) { + if (jQuery.nodeName((tbody = elem.childNodes[j]), "tbody") + && !tbody.childNodes.length) { + + elem.removeChild(tbody); + } + } + } + + jQuery.merge(nodes, tmp.childNodes); + + // Fix #12392 for WebKit and IE > 9 + tmp.textContent = ""; + + // Fix #12392 for oldIE + while (tmp.firstChild) { + tmp.removeChild(tmp.firstChild); + } + + // Remember the top-level container for + // proper cleanup + tmp = safe.lastChild; + } + } + } + + // Fix #11356: Clear elements from fragment + if (tmp) { + safe.removeChild(tmp); + } + + // Reset defaultChecked for any radios and checkboxes + // about to be appended to the DOM in IE 6/7 (#8060) + if (!support.appendChecked) { + jQuery.grep(getAll(nodes, "input"), fixDefaultChecked); + } + + i = 0; + while ((elem = nodes[i++])) { + + // Skip elements already in the context collection + // (trac-4087) + if (selection && jQuery.inArray(elem, selection) > -1) { + if (ignored) { + ignored.push(elem); + } + + continue; + } + + contains = jQuery.contains(elem.ownerDocument, elem); + + // Append to fragment + tmp = getAll(safe.appendChild(elem), "script"); + + // Preserve script evaluation history + if (contains) { + setGlobalEval(tmp); + } + + // Capture executables + if (scripts) { + j = 0; + while ((elem = tmp[j++])) { + if (rscriptType.test(elem.type || "")) { + scripts.push(elem); + } + } + } + } + + tmp = null; + + return safe; + } + + (function() { + var i, eventName, div = document.createElement("div"); + + // Support: IE<9 (lack submit/change bubble), Firefox + // (lack focus(in | out) events) + for (i in { + submit : true, + change : true, + focusin : true + }) { + eventName = "on" + i; + + if (!(support[i] = eventName in window)) { + + // Beware of CSP restrictions + // (https://developer.mozilla.org/en/Security/CSP) + div.setAttribute(eventName, "t"); + support[i] = div.attributes[eventName].expando === false; + } + } + + // Null elements to avoid leaks in IE. + div = null; + })(); + + var rformElems = /^(?:input|select|textarea)$/i, rkeyEvent = /^key/, rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, rtypenamespace = /^([^.]*)(?:\.(.+)|)/; + + function returnTrue() { + return true; + } + + function returnFalse() { + return false; + } + + // Support: IE9 + // See #13393 for more info + function safeActiveElement() { + try { + return document.activeElement; + } catch (err) { + } + } + + function on(elem, types, selector, data, fn, one) { + var origFn, type; + + // Types can be a map of types/handlers + if (typeof types === "object") { + + // ( types-Object, selector, data ) + if (typeof selector !== "string") { + + // ( types-Object, data ) + data = data || selector; + selector = undefined; + } + for (type in types) { + on(elem, type, selector, data, types[type], one); + } + return elem; + } + + 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 elem; + } + + 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 elem.each(function() { + jQuery.event.add(this, types, fn, data, selector); + }); + } + + /* + * Helper functions for managing events -- not part of the + * public interface. Props to Dean Edwards' addEvent library + * for many of the ideas. + */ + jQuery.event = { + + global : {}, + + add : function(elem, types, handler, data, selector) { + var tmp, events, t, handleObjIn, special, eventHandle, handleObj, handlers, type, namespaces, origType, elemData = jQuery + ._data(elem); + + // Don't attach events to noData or text/comment + // nodes (but allow plain objects) + if (!elemData) { + 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 + if (!(events = elemData.events)) { + events = elemData.events = {}; + } + if (!(eventHandle = elemData.handle)) { + eventHandle = elemData.handle = 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 + types = (types || "").match(rnotwhite) || [ "" ]; + t = types.length; + while (t--) { + tmp = rtypenamespace.exec(types[t]) || []; + type = origType = tmp[1]; + namespaces = (tmp[2] || "").split(".").sort(); + + // There *must* be a type, no attaching + // namespace-only handlers + if (!type) { + continue; + } + + // 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 : origType, + data : data, + handler : handler, + guid : handler.guid, + selector : selector, + needsContext : selector && jQuery.expr.match.needsContext.test(selector), + namespace : namespaces.join(".") + }, handleObjIn); + + // Init the event handler queue if we're the + // first + if (!(handlers = events[type])) { + 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; + }, + + // Detach an event or set of events from an element + remove : function(elem, types, handler, selector, mappedTypes) { + var j, handleObj, tmp, origCount, t, events, special, handlers, type, namespaces, origType, elemData = jQuery + .hasData(elem) + && jQuery._data(elem); + + if (!elemData || !(events = elemData.events)) { + return; + } + + // Once for each type.namespace in types; type may + // be omitted + types = (types || "").match(rnotwhite) || [ "" ]; + t = types.length; + while (t--) { + tmp = rtypenamespace.exec(types[t]) || []; + type = origType = tmp[1]; + namespaces = (tmp[2] || "").split(".").sort(); + + // 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; + handlers = events[type] || []; + tmp = tmp[2] && new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)"); + + // Remove matching events + origCount = j = handlers.length; + while (j--) { + handleObj = handlers[j]; + + if ((mappedTypes || origType === handleObj.origType) + && (!handler || handler.guid === handleObj.guid) + && (!tmp || tmp.test(handleObj.namespace)) + && (!selector || selector === handleObj.selector || selector === "**" + && handleObj.selector)) { + handlers.splice(j, 1); + + if (handleObj.selector) { + handlers.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 (origCount && !handlers.length) { + if (!special.teardown + || special.teardown.call(elem, namespaces, elemData.handle) === false) { + + jQuery.removeEvent(elem, type, elemData.handle); + } + + delete events[type]; + } + } + + // Remove the expando if it's no longer used + if (jQuery.isEmptyObject(events)) { + delete elemData.handle; + + // removeData also checks for emptiness and + // clears the expando if empty + // so use it instead of delete + jQuery._removeData(elem, "events"); + } + }, + + trigger : function(event, data, elem, onlyHandlers) { + var handle, ontype, cur, bubbleType, special, tmp, i, eventPath = [ elem || document ], type = hasOwn + .call(event, "type") ? event.type : event, namespaces = hasOwn.call(event, + "namespace") ? event.namespace.split(".") : []; + + cur = tmp = elem = elem || document; + + // Don't do events on text and comment nodes + if (elem.nodeType === 3 || elem.nodeType === 8) { + return; + } + + // 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(".") > -1) { + + // Namespaced trigger; create a regexp to match + // event type in handle() + namespaces = type.split("."); + type = namespaces.shift(); + namespaces.sort(); + } + ontype = type.indexOf(":") < 0 && "on" + type; + + // Caller can pass in a jQuery.Event object, Object, + // or just an event type string + event = event[jQuery.expando] ? event : new jQuery.Event(type, typeof event === "object" + && event); + + // Trigger bitmask: & 1 for native handlers; & 2 for + // jQuery (always true) + event.isTrigger = onlyHandlers ? 2 : 3; + event.namespace = namespaces.join("."); + event.rnamespace = event.namespace ? new RegExp("(^|\\.)" + + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null; + + // 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 ? [ event ] : jQuery.makeArray(data, [ event ]); + + // Allow special events to draw outside the lines + special = jQuery.event.special[type] || {}; + if (!onlyHandlers && 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) + if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) { + + bubbleType = special.delegateType || type; + if (!rfocusMorph.test(bubbleType + type)) { + cur = cur.parentNode; + } + for (; cur; cur = cur.parentNode) { + eventPath.push(cur); + tmp = cur; + } + + // Only add window if we got to document (e.g., + // not plain obj or detached DOM) + if (tmp === (elem.ownerDocument || document)) { + eventPath.push(tmp.defaultView || tmp.parentWindow || window); + } + } + + // Fire handlers on the event path + i = 0; + while ((cur = eventPath[i++]) && !event.isPropagationStopped()) { + + event.type = i > 1 ? bubbleType : special.bindType || type; + + // jQuery handler + handle = (jQuery._data(cur, "events") || {})[event.type] && jQuery._data(cur, "handle"); + + if (handle) { + handle.apply(cur, data); + } + + // Native handler + handle = ontype && cur[ontype]; + if (handle && handle.apply && acceptData(cur)) { + event.result = handle.apply(cur, data); + if (event.result === 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(eventPath.pop(), data) === false) + && 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) + if (ontype && elem[type] && !jQuery.isWindow(elem)) { + + // Don't re-trigger an onFOO event when + // we call its FOO() method + tmp = elem[ontype]; + + if (tmp) { + elem[ontype] = null; + } + + // Prevent re-triggering of the same + // event, since we already bubbled it + // above + jQuery.event.triggered = type; + try { + elem[type](); + } catch (e) { + + // IE<9 dies on focus/blur to hidden + // element (#1486,#12518) + // only reproducible on winXP IE8 + // native, not IE9 in IE8 mode + } + jQuery.event.triggered = undefined; + + if (tmp) { + elem[ontype] = tmp; + } + } + } + } + + return event.result; + }, + + dispatch : function(event) { + + // Make a writable jQuery.Event from the native + // event object + event = jQuery.event.fix(event); + + var i, j, ret, matched, handleObj, handlerQueue = [], args = slice.call(arguments), handlers = (jQuery + ._data(this, "events") || {})[event.type] + || [], special = jQuery.event.special[event.type] || {}; + + // 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 + handlerQueue = jQuery.event.handlers.call(this, event, handlers); + + // Run delegates first; they may want to stop + // propagation beneath us + i = 0; + while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) { + event.currentTarget = matched.elem; + + j = 0; + while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) { + + // Triggered event must either 1) have no + // namespace, or 2) have namespace(s) + // a subset or equal to those in the bound + // event (both can have no namespace). + if (!event.rnamespace || event.rnamespace.test(handleObj.namespace)) { + + event.handleObj = handleObj; + event.data = handleObj.data; + + ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler) + .apply(matched.elem, args); + + if (ret !== undefined) { + if ((event.result = 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; + }, + + handlers : function(event, handlers) { + var i, matches, sel, handleObj, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target; + + // Support (at least): Chrome, IE9 + // Find delegate handlers + // Black-hole SVG <use> instance trees (#13180) + // + // Support: Firefox<=42+ + // Avoid non-left-click in FF but don't block IE + // radio events (#3861, gh-2343) + if (delegateCount && cur.nodeType + && (event.type !== "click" || isNaN(event.button) || event.button < 1)) { + + /* jshint eqeqeq: false */ + for (; cur != this; cur = cur.parentNode || this) { + /* jshint eqeqeq: true */ + + // Don't check non-elements (#13208) + // Don't process clicks on disabled elements + // (#6911, #8165, #11382, #11764) + if (cur.nodeType === 1 && (cur.disabled !== true || event.type !== "click")) { + matches = []; + for (i = 0; i < delegateCount; i++) { + handleObj = handlers[i]; + + // Don't conflict with + // Object.prototype properties + // (#13203) + sel = handleObj.selector + " "; + + if (matches[sel] === undefined) { + matches[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) > -1 + : jQuery.find(sel, this, null, [ cur ]).length; + } + if (matches[sel]) { + matches.push(handleObj); + } + } + if (matches.length) { + handlerQueue.push({ + elem : cur, + handlers : matches + }); + } + } + } + } + + // Add the remaining (directly-bound) handlers + if (delegateCount < handlers.length) { + handlerQueue.push({ + elem : this, + handlers : handlers.slice(delegateCount) + }); + } + + return handlerQueue; + }, + + fix : function(event) { + if (event[jQuery.expando]) { + return event; + } + + // Create a writable copy of the event object and + // normalize some properties + var i, prop, copy, type = event.type, originalEvent = event, fixHook = this.fixHooks[type]; + + if (!fixHook) { + this.fixHooks[type] = fixHook = rmouseEvent.test(type) ? this.mouseHooks : rkeyEvent + .test(type) ? this.keyHooks : {}; + } + copy = fixHook.props ? this.props.concat(fixHook.props) : this.props; + + event = new jQuery.Event(originalEvent); + + i = copy.length; + while (i--) { + prop = copy[i]; + event[prop] = originalEvent[prop]; + } + + // Support: IE<9 + // Fix target property (#1925) + if (!event.target) { + event.target = originalEvent.srcElement || document; + } + + // Support: Safari 6-8+ + // Target should not be a text node (#504, #13143) + if (event.target.nodeType === 3) { + event.target = event.target.parentNode; + } + + // Support: IE<9 + // For mouse/key events, metaKey==false if it's + // undefined (#3368, #11328) + event.metaKey = !!event.metaKey; + + return fixHook.filter ? fixHook.filter(event, originalEvent) : event; + }, + + // Includes some event props shared by KeyEvent and + // MouseEvent + props : ("altKey bubbles cancelable ctrlKey currentTarget detail 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 body, eventDoc, doc, 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; + } + }, + + special : { + load : { + + // Prevent triggered image.load events from + // bubbling to window.load + noBubble : true + }, + focus : { + + // Fire native event if possible so blur/focus + // sequence is correct + trigger : function() { + if (this !== safeActiveElement() && this.focus) { + try { + this.focus(); + return false; + } catch (e) { + + // Support: IE<9 + // If we error on focus to hidden + // element (#1486, #12518), + // let .trigger() run the handlers + } + } + }, + delegateType : "focusin" + }, + blur : { + trigger : function() { + if (this === safeActiveElement() && this.blur) { + this.blur(); + return false; + } + }, + delegateType : "focusout" + }, + click : { + + // For checkbox, fire native event so checked + // state will be right + trigger : function() { + if (jQuery.nodeName(this, "input") && this.type === "checkbox" && this.click) { + this.click(); + return false; + } + }, + + // For cross-browser consistency, don't fire + // native .click() on links + _default : function(event) { + return jQuery.nodeName(event.target, "a"); + } + }, + + beforeunload : { + postDispatch : function(event) { + + // Support: Firefox 20+ + // Firefox doesn't alert if the returnValue + // field is not set. + if (event.result !== undefined && event.originalEvent) { + event.originalEvent.returnValue = event.result; + } + } + } + }, + + // Piggyback on a donor event to simulate a different + // one + simulate : function(type, elem, event) { + var e = jQuery.extend(new jQuery.Event(), event, { + type : type, + isSimulated : true + + // Previously, `originalEvent: {}` was set here, so + // stopPropagation call + // would not be triggered on donor event, since in + // our own + // jQuery.event.stopPropagation function we had a + // check for existence of + // originalEvent.stopPropagation method, so, + // consequently it would be a noop. + // + // Guard for simulated events was moved to + // jQuery.event.stopPropagation function + // since `originalEvent` should point to the + // original event for the + // constancy with other events and for more focused + // logic + }); + + jQuery.event.trigger(e, null, elem); + + if (e.isDefaultPrevented()) { + event.preventDefault(); + } + } + }; + + jQuery.removeEvent = document.removeEventListener ? function(elem, type, handle) { + + // This "if" is needed for plain objects + if (elem.removeEventListener) { + elem.removeEventListener(type, handle); + } + } : function(elem, type, handle) { + var name = "on" + type; + + if (elem.detachEvent) { + + // #8545, #7054, preventing memory leaks for + // custom events in IE6-8 + // detachEvent needed property on element, + // by name of that event, + // to properly expose it to GC + if (typeof elem[name] === "undefined") { + elem[name] = null; + } + + elem.detachEvent(name, 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.defaultPrevented === undefined && + + // Support: IE < 9, Android < 4.0 + src.returnValue === false ? 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; + }; + + // jQuery.Event is based on DOM3 Events as specified by the + // ECMAScript Language Binding + // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html + jQuery.Event.prototype = { + constructor : jQuery.Event, + isDefaultPrevented : returnFalse, + isPropagationStopped : returnFalse, + isImmediatePropagationStopped : returnFalse, + + preventDefault : function() { + var e = this.originalEvent; + + this.isDefaultPrevented = returnTrue; + if (!e) { + return; + } + + // If preventDefault exists, run it on the original + // event + if (e.preventDefault) { + e.preventDefault(); + + // Support: IE + // Otherwise set the returnValue property of the + // original event to false + } else { + e.returnValue = false; + } + }, + stopPropagation : function() { + var e = this.originalEvent; + + this.isPropagationStopped = returnTrue; + + if (!e || this.isSimulated) { + return; + } + + // If stopPropagation exists, run it on the original + // event + if (e.stopPropagation) { + e.stopPropagation(); + } + + // Support: IE + // Set the cancelBubble property of the original + // event to true + e.cancelBubble = true; + }, + stopImmediatePropagation : function() { + var e = this.originalEvent; + + this.isImmediatePropagationStopped = returnTrue; + + if (e && e.stopImmediatePropagation) { + e.stopImmediatePropagation(); + } + + this.stopPropagation(); + } + }; + + // Create mouseenter/leave events using mouseover/out and + // event-time checks + // so that event delegation works in jQuery. + // Do the same for pointerenter/pointerleave and + // pointerover/pointerout + // + // Support: Safari 7 only + // Safari sends mouseenter too often; see: + // https://code.google.com/p/chromium/issues/detail?id=470258 + // for the description of the bug (it existed in older + // Chrome versions as well). + jQuery.each({ + mouseenter : "mouseover", + mouseleave : "mouseout", + pointerenter : "pointerover", + pointerleave : "pointerout" + }, function(orig, fix) { + jQuery.event.special[orig] = { + delegateType : fix, + bindType : fix, + + handle : function(event) { + var ret, target = this, related = event.relatedTarget, handleObj = event.handleObj; + + // For mouseenter/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 (!support.submit) { + + 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") ? + + // Support: IE <=8 + // We use jQuery.prop + // instead of elem.form + // to allow fixing the IE8 + // delegated submit issue + // (gh-2332) + // by 3rd party + // polyfills/workarounds. + jQuery.prop(elem, "form") : undefined; + + if (form && !jQuery._data(form, "submit")) { + jQuery.event.add(form, "submit._submit", function(event) { + event._submitBubble = true; + }); + jQuery._data(form, "submit", 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._submitBubble) { + delete event._submitBubble; + if (this.parentNode && !event.isTrigger) { + jQuery.event.simulate("submit", this.parentNode, event); + } + } + }, + + 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 (!support.change) { + + 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._justChanged = true; + } + }); + jQuery.event.add(this, "click._change", function(event) { + if (this._justChanged && !event.isTrigger) { + this._justChanged = false; + } + + // Allow triggered, + // simulated change + // events (#11500) + jQuery.event.simulate("change", this, event); + }); + } + 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) && !jQuery._data(elem, "change")) { + jQuery.event.add(elem, "change._change", function(event) { + if (this.parentNode && !event.isSimulated && !event.isTrigger) { + jQuery.event.simulate("change", this.parentNode, event); + } + }); + jQuery._data(elem, "change", 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); + } + }; + } + + // Support: Firefox + // Firefox doesn't have focus(in | out) events + // Related ticket - + // https://bugzilla.mozilla.org/show_bug.cgi?id=687787 + // + // Support: Chrome, Safari + // focus(in | out) events fire after focus & blur events, + // which is spec violation - + // http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order + // Related ticket - + // https://code.google.com/p/chromium/issues/detail?id=449857 + if (!support.focusin) { + jQuery.each({ + focus : "focusin", + blur : "focusout" + }, function(orig, fix) { + + // Attach a single capturing handler on the + // document while someone wants + // focusin/focusout + var handler = function(event) { + jQuery.event.simulate(fix, event.target, jQuery.event.fix(event)); + }; + + jQuery.event.special[fix] = { + setup : function() { + var doc = this.ownerDocument || this, attaches = jQuery._data(doc, fix); + + if (!attaches) { + doc.addEventListener(orig, handler, true); + } + jQuery._data(doc, fix, (attaches || 0) + 1); + }, + teardown : function() { + var doc = this.ownerDocument || this, attaches = jQuery._data(doc, fix) - 1; + + if (!attaches) { + doc.removeEventListener(orig, handler, true); + jQuery._removeData(doc, fix); + } else { + jQuery._data(doc, fix, attaches); + } + } + }; + }); + } + + jQuery.fn.extend({ + + on : function(types, selector, data, fn) { + return on(this, types, selector, data, fn); + }, + one : function(types, selector, data, fn) { + return on(this, types, selector, data, fn, 1); + }, + off : function(types, selector, fn) { + var handleObj, type; + if (types && types.preventDefault && types.handleObj) { + + // ( event ) dispatched jQuery.Event + 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 (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); + }); + }, + + trigger : function(type, data) { + return this.each(function() { + jQuery.event.trigger(type, data, this); + }); + }, + triggerHandler : function(type, data) { + var elem = this[0]; + if (elem) { + return jQuery.event.trigger(type, data, elem, true); + } + } + }); + + var rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g, rnoshimcache = new RegExp("<(?:" + nodeNames + + ")[\\s/>]", "i"), rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi, + + // Support: IE 10-11, Edge 10240+ + // In IE/Edge using regex groups here causes severe + // slowdowns. + // See + // https://connect.microsoft.com/IE/feedback/details/1736512/ + rnoInnerhtml = /<script|<style|<link/i, + + // checked="checked" or checked + rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, rscriptTypeMasked = /^true\/(.*)/, rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g, safeFragment = createSafeFragment(document), fragmentDiv = safeFragment + .appendChild(document.createElement("div")); + + // Support: IE<8 + // Manipulating tables requires a tbody + function manipulationTarget(elem, content) { + return jQuery.nodeName(elem, "table") + && jQuery.nodeName(content.nodeType !== 11 ? content : content.firstChild, "tr") ? + + elem.getElementsByTagName("tbody")[0] + || elem.appendChild(elem.ownerDocument.createElement("tbody")) : elem; + } + + // Replace/restore the type attribute of script elements for + // safe DOM manipulation + function disableScript(elem) { + elem.type = (jQuery.find.attr(elem, "type") !== null) + "/" + elem.type; + return elem; + } + function restoreScript(elem) { + var match = rscriptTypeMasked.exec(elem.type); + if (match) { + elem.type = match[1]; + } else { + elem.removeAttribute("type"); + } + return 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 fixCloneNodeIssues(src, dest) { + var nodeName, e, data; + + // We do not need to do anything for non-Elements + if (dest.nodeType !== 1) { + return; + } + + nodeName = dest.nodeName.toLowerCase(); + + // IE6-8 copies events bound via attachEvent when using + // cloneNode. + if (!support.noCloneEvent && dest[jQuery.expando]) { + data = jQuery._data(dest); + + for (e in data.events) { + jQuery.removeEvent(dest, e, data.handle); + } + + // Event data gets referenced instead of copied if + // the expando gets copied too + dest.removeAttribute(jQuery.expando); + } + + // IE blanks contents when cloning scripts, and tries to + // evaluate newly-set text + if (nodeName === "script" && dest.text !== src.text) { + disableScript(dest).text = src.text; + restoreScript(dest); + + // IE6-10 improperly clones children of object + // elements using classid. + // IE10 throws NoModificationAllowedError if parent + // is null, #12132. + } else if (nodeName === "object") { + if (dest.parentNode) { + dest.outerHTML = src.outerHTML; + } + + // This path appears unavoidable for IE9. When + // cloning an object + // element in IE9, the outerHTML strategy above is + // not sufficient. + // If the src has innerHTML and the destination does + // not, + // copy the src.innerHTML into the dest.innerHTML. + // #10324 + if (support.html5Clone && (src.innerHTML && !jQuery.trim(dest.innerHTML))) { + dest.innerHTML = src.innerHTML; + } + + } else if (nodeName === "input" && rcheckableType.test(src.type)) { + + // 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 + + 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.defaultSelected = 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; + } + } + + function domManip(collection, args, callback, ignored) { + + // Flatten any nested arrays + args = concat.apply([], args); + + var first, node, hasScripts, scripts, doc, fragment, i = 0, l = collection.length, iNoClone = l - 1, value = args[0], isFunction = jQuery + .isFunction(value); + + // We can't cloneNode fragments that contain checked, in + // WebKit + if (isFunction + || (l > 1 && typeof value === "string" && !support.checkClone && rchecked.test(value))) { + return collection.each(function(index) { + var self = collection.eq(index); + if (isFunction) { + args[0] = value.call(this, index, self.html()); + } + domManip(self, args, callback, ignored); + }); + } + + if (l) { + fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored); + first = fragment.firstChild; + + if (fragment.childNodes.length === 1) { + fragment = first; + } + + // Require either new content or an interest in + // ignored elements to invoke the callback + if (first || ignored) { + scripts = jQuery.map(getAll(fragment, "script"), disableScript); + hasScripts = scripts.length; + + // Use the original fragment for the last item + // instead of the first because it can end up + // being emptied incorrectly in certain + // situations (#8070). + for (; i < l; i++) { + node = fragment; + + if (i !== iNoClone) { + node = jQuery.clone(node, true, true); + + // Keep references to cloned scripts for + // later restoration + if (hasScripts) { + + // Support: Android<4.1, PhantomJS<2 + // push.apply(_, arraylike) throws + // on ancient WebKit + jQuery.merge(scripts, getAll(node, "script")); + } + } + + callback.call(collection[i], node, i); + } + + if (hasScripts) { + doc = scripts[scripts.length - 1].ownerDocument; + + // Reenable scripts + jQuery.map(scripts, restoreScript); + + // Evaluate executable scripts on first + // document insertion + for (i = 0; i < hasScripts; i++) { + node = scripts[i]; + if (rscriptType.test(node.type || "") && !jQuery._data(node, "globalEval") + && jQuery.contains(doc, node)) { + + if (node.src) { + + // Optional AJAX dependency, but + // won't run scripts if not + // present + if (jQuery._evalUrl) { + jQuery._evalUrl(node.src); + } + } else { + jQuery + .globalEval((node.text || node.textContent || node.innerHTML || "") + .replace(rcleanScript, "")); + } + } + } + } + + // Fix #11809: Avoid leaking memory + fragment = first = null; + } + } + + return collection; + } + + function remove(elem, selector, keepData) { + var node, elems = selector ? jQuery.filter(selector, elem) : elem, i = 0; + + for (; (node = elems[i]) != null; i++) { + + if (!keepData && node.nodeType === 1) { + jQuery.cleanData(getAll(node)); + } + + if (node.parentNode) { + if (keepData && jQuery.contains(node.ownerDocument, node)) { + setGlobalEval(getAll(node, "script")); + } + node.parentNode.removeChild(node); + } + } + + return elem; + } + + jQuery + .extend({ + htmlPrefilter : function(html) { + return html.replace(rxhtmlTag, "<$1></$2>"); + }, + + clone : function(elem, dataAndEvents, deepDataAndEvents) { + var destElements, node, clone, i, srcElements, inPage = jQuery.contains( + elem.ownerDocument, elem); + + if (support.html5Clone || jQuery.isXMLDoc(elem) + || !rnoshimcache.test("<" + elem.nodeName + ">")) { + + clone = elem.cloneNode(true); + + // IE<=8 does not properly clone + // detached, unknown element nodes + } else { + fragmentDiv.innerHTML = elem.outerHTML; + fragmentDiv.removeChild(clone = fragmentDiv.firstChild); + } + + if ((!support.noCloneEvent || !support.noCloneChecked) + && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) { + + // We eschew Sizzle here for performance + // reasons: + // http://jsperf.com/getall-vs-sizzle/2 + destElements = getAll(clone); + srcElements = getAll(elem); + + // Fix all IE cloning issues + for (i = 0; (node = srcElements[i]) != null; ++i) { + + // Ensure that the destination node + // is not null; Fixes #9587 + if (destElements[i]) { + fixCloneNodeIssues(node, destElements[i]); + } + } + } + + // Copy the events from the original to the + // clone + if (dataAndEvents) { + if (deepDataAndEvents) { + srcElements = srcElements || getAll(elem); + destElements = destElements || getAll(clone); + + for (i = 0; (node = srcElements[i]) != null; i++) { + cloneCopyEvent(node, destElements[i]); + } + } else { + cloneCopyEvent(elem, clone); + } + } + + // Preserve script evaluation history + destElements = getAll(clone, "script"); + if (destElements.length > 0) { + setGlobalEval(destElements, !inPage && getAll(elem, "script")); + } + + destElements = srcElements = node = null; + + // Return the cloned set + return clone; + }, + + cleanData : function(elems, /* internal */ + forceAcceptData) { + var elem, type, id, data, i = 0, internalKey = jQuery.expando, cache = jQuery.cache, attributes = support.attributes, special = jQuery.event.special; + + for (; (elem = elems[i]) != null; i++) { + if (forceAcceptData || acceptData(elem)) { + + id = elem[internalKey]; + data = id && cache[id]; + + if (data) { + if (data.events) { + for (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); + } + } + } + + // Remove cache only if it was + // not already removed by + // jQuery.event.remove + if (cache[id]) { + + delete cache[id]; + + // Support: IE<9 + // IE does not allow us to + // delete expando properties + // from nodes + // IE creates expando + // attributes along with the + // property + // IE does not have a + // removeAttribute function + // on Document nodes + if (!attributes && typeof elem.removeAttribute !== "undefined") { + elem.removeAttribute(internalKey); + + // Webkit & Blink + // performance suffers + // when deleting + // properties + // from DOM nodes, so + // set to undefined + // instead + // https://code.google.com/p/chromium/issues/detail?id=378607 + } else { + elem[internalKey] = undefined; + } + + deletedIds.push(id); + } + } + } + } + } + }); + + jQuery.fn.extend({ + + // Keep domManip exposed until 3.0 (gh-2225) + domManip : domManip, + + detach : function(selector) { + return remove(this, selector, true); + }, + + remove : function(selector) { + return remove(this, selector); + }, + + text : function(value) { + return 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); + }, + + append : function() { + return domManip(this, arguments, function(elem) { + if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) { + var target = manipulationTarget(this, elem); + target.appendChild(elem); + } + }); + }, + + prepend : function() { + return domManip(this, arguments, function(elem) { + if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) { + var target = manipulationTarget(this, elem); + target.insertBefore(elem, target.firstChild); + } + }); + }, + + before : function() { + return domManip(this, arguments, function(elem) { + if (this.parentNode) { + this.parentNode.insertBefore(elem, this); + } + }); + }, + + after : function() { + return domManip(this, arguments, function(elem) { + if (this.parentNode) { + this.parentNode.insertBefore(elem, this.nextSibling); + } + }); + }, + + empty : function() { + var elem, i = 0; + + for (; (elem = this[i]) != null; i++) { + + // Remove element nodes and prevent + // memory leaks + if (elem.nodeType === 1) { + jQuery.cleanData(getAll(elem, false)); + } + + // Remove any remaining nodes + while (elem.firstChild) { + elem.removeChild(elem.firstChild); + } + + // If this is a select, ensure that it + // displays empty (#12336) + // Support: IE<9 + if (elem.options && jQuery.nodeName(elem, "select")) { + elem.options.length = 0; + } + } + + 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 access(this, function(value) { + var elem = this[0] || {}, i = 0, l = this.length; + + if (value === undefined) { + return elem.nodeType === 1 ? elem.innerHTML.replace(rinlinejQuery, "") : undefined; + } + + // See if we can take a shortcut + // and just use innerHTML + if (typeof value === "string" && !rnoInnerhtml.test(value) + && (support.htmlSerialize || !rnoshimcache.test(value)) + && (support.leadingWhitespace || !rleadingWhitespace.test(value)) + && !wrapMap[(rtagName.exec(value) || [ "", "" ])[1].toLowerCase()]) { + + value = jQuery.htmlPrefilter(value); + + try { + for (; i < l; i++) { + + // Remove element + // nodes and prevent + // memory leaks + elem = this[i] || {}; + if (elem.nodeType === 1) { + jQuery.cleanData(getAll(elem, false)); + 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() { + var ignored = []; + + // Make the changes, replacing each + // non-ignored context element with the new + // content + return domManip(this, arguments, function(elem) { + var parent = this.parentNode; + + if (jQuery.inArray(this, ignored) < 0) { + jQuery.cleanData(getAll(this)); + if (parent) { + parent.replaceChild(elem, this); + } + } + + // Force callback invocation + }, ignored); + } + }); + + jQuery.each({ + appendTo : "append", + prependTo : "prepend", + insertBefore : "before", + insertAfter : "after", + replaceAll : "replaceWith" + }, function(name, original) { + jQuery.fn[name] = function(selector) { + var elems, i = 0, ret = [], insert = jQuery(selector), last = insert.length - 1; + + for (; i <= last; i++) { + elems = i === last ? this : this.clone(true); + jQuery(insert[i])[original](elems); + + // Modern browsers can apply + // jQuery collections as arrays, + // but oldIE needs a .get() + push.apply(ret, elems.get()); + } + + return this.pushStack(ret); + }; + }); + + var iframe, elemdisplay = { + + // Support: Firefox + // We have to pre-define these values for FF (#10227) + HTML : "block", + BODY : "block" + }; + + /** + * Retrieve the actual display of a element + * + * @param {String} + * name nodeName of the element + * @param {Object} + * doc Document object + */ + + // Called only from within defaultDisplay + function actualDisplay(name, doc) { + var elem = jQuery(doc.createElement(name)).appendTo(doc.body), + + display = jQuery.css(elem[0], "display"); + + // We don't have any data stored on the element, + // so use "detach" method as fast way to get rid of the + // element + elem.detach(); + + return display; + } + + /** + * Try to determine the default display value of an element + * + * @param {String} + * nodeName + */ + function defaultDisplay(nodeName) { + var doc = document, display = elemdisplay[nodeName]; + + if (!display) { + display = actualDisplay(nodeName, doc); + + // If the simple way fails, read from inside an + // iframe + if (display === "none" || !display) { + + // Use the already-created iframe if possible + iframe = (iframe || jQuery("<iframe frameborder='0' width='0' height='0'/>")) + .appendTo(doc.documentElement); + + // Always write a new HTML skeleton so Webkit + // and Firefox don't choke on reuse + doc = (iframe[0].contentWindow || iframe[0].contentDocument).document; + + // Support: IE + doc.write(); + doc.close(); + + display = actualDisplay(nodeName, doc); + iframe.detach(); + } + + // Store the correct default display + elemdisplay[nodeName] = display; + } + + return display; + } + var rmargin = (/^margin/); + + var rnumnonpx = new RegExp("^(" + pnum + ")(?!px)[a-z%]+$", "i"); + + var swap = function(elem, options, callback, args) { + var ret, name, old = {}; + + // 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.apply(elem, args || []); + + // Revert the old values + for (name in options) { + elem.style[name] = old[name]; + } + + return ret; + }; + + var documentElement = document.documentElement; + + (function() { + var pixelPositionVal, pixelMarginRightVal, boxSizingReliableVal, reliableHiddenOffsetsVal, reliableMarginRightVal, reliableMarginLeftVal, container = document + .createElement("div"), div = document.createElement("div"); + + // Finish early in limited (non-browser) environments + if (!div.style) { + return; + } + + div.style.cssText = "float:left;opacity:.5"; + + // Support: IE<9 + // Make sure that element opacity exists (as opposed to + // filter) + support.opacity = div.style.opacity === "0.5"; + + // Verify style float existence + // (IE uses styleFloat instead of cssFloat) + support.cssFloat = !!div.style.cssFloat; + + div.style.backgroundClip = "content-box"; + div.cloneNode(true).style.backgroundClip = ""; + support.clearCloneStyle = div.style.backgroundClip === "content-box"; + + container = document.createElement("div"); + container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" + + "padding:0;margin-top:1px;position:absolute"; + div.innerHTML = ""; + container.appendChild(div); + + // Support: Firefox<29, Android 2.3 + // Vendor-prefix box-sizing + support.boxSizing = div.style.boxSizing === "" || div.style.MozBoxSizing === "" + || div.style.WebkitBoxSizing === ""; + + jQuery.extend(support, { + reliableHiddenOffsets : function() { + if (pixelPositionVal == null) { + computeStyleTests(); + } + return reliableHiddenOffsetsVal; + }, + + boxSizingReliable : function() { + + // We're checking for pixelPositionVal here + // instead of boxSizingReliableVal + // since that compresses better and they're + // computed together anyway. + if (pixelPositionVal == null) { + computeStyleTests(); + } + return boxSizingReliableVal; + }, + + pixelMarginRight : function() { + + // Support: Android 4.0-4.3 + if (pixelPositionVal == null) { + computeStyleTests(); + } + return pixelMarginRightVal; + }, + + pixelPosition : function() { + if (pixelPositionVal == null) { + computeStyleTests(); + } + return pixelPositionVal; + }, + + reliableMarginRight : function() { + + // Support: Android 2.3 + if (pixelPositionVal == null) { + computeStyleTests(); + } + return reliableMarginRightVal; + }, + + reliableMarginLeft : function() { + + // Support: IE <=8 only, Android 4.0 - 4.3 only, + // Firefox <=3 - 37 + if (pixelPositionVal == null) { + computeStyleTests(); + } + return reliableMarginLeftVal; + } + }); + + function computeStyleTests() { + var contents, divStyle, documentElement = document.documentElement; + + // Setup + documentElement.appendChild(container); + + div.style.cssText = + + // Support: Android 2.3 + // Vendor-prefix box-sizing + "-webkit-box-sizing:border-box;box-sizing:border-box;" + "position:relative;display:block;" + + "margin:auto;border:1px;padding:1px;" + "top:1%;width:50%"; + + // Support: IE<9 + // Assume reasonable values in the absence of + // getComputedStyle + pixelPositionVal = boxSizingReliableVal = reliableMarginLeftVal = false; + pixelMarginRightVal = reliableMarginRightVal = true; + + // Check for getComputedStyle so that this code is + // not run in IE<9. + if (window.getComputedStyle) { + divStyle = window.getComputedStyle(div); + pixelPositionVal = (divStyle || {}).top !== "1%"; + reliableMarginLeftVal = (divStyle || {}).marginLeft === "2px"; + boxSizingReliableVal = (divStyle || { + width : "4px" + }).width === "4px"; + + // Support: Android 4.0 - 4.3 only + // Some styles come back with percentage values, + // even though they shouldn't + div.style.marginRight = "50%"; + pixelMarginRightVal = (divStyle || { + marginRight : "4px" + }).marginRight === "4px"; + + // Support: Android 2.3 only + // Div with explicit width and no margin-right + // incorrectly + // gets computed margin-right based on width of + // container (#3333) + // WebKit Bug 13343 - getComputedStyle returns + // wrong value for margin-right + contents = div.appendChild(document.createElement("div")); + + // Reset CSS: box-sizing; display; margin; + // border; padding + contents.style.cssText = div.style.cssText = + + // Support: Android 2.3 + // Vendor-prefix box-sizing + "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" + + "box-sizing:content-box;display:block;margin:0;border:0;padding:0"; + contents.style.marginRight = contents.style.width = "0"; + div.style.width = "1px"; + + reliableMarginRightVal = !parseFloat((window.getComputedStyle(contents) || {}).marginRight); + + div.removeChild(contents); + } + + // Support: IE6-8 + // First check that getClientRects works as expected + // 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). + div.style.display = "none"; + reliableHiddenOffsetsVal = div.getClientRects().length === 0; + if (reliableHiddenOffsetsVal) { + div.style.display = ""; + div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>"; + div.childNodes[0].style.borderCollapse = "separate"; + contents = div.getElementsByTagName("td"); + contents[0].style.cssText = "margin:0;border:0;padding:0;display:none"; + reliableHiddenOffsetsVal = contents[0].offsetHeight === 0; + if (reliableHiddenOffsetsVal) { + contents[0].style.display = ""; + contents[1].style.display = "none"; + reliableHiddenOffsetsVal = contents[0].offsetHeight === 0; + } + } + + // Teardown + documentElement.removeChild(container); + } + + })(); + + var getStyles, curCSS, rposition = /^(top|right|bottom|left)$/; + + if (window.getComputedStyle) { + getStyles = function(elem) { + + // Support: IE<=11+, Firefox<=30+ (#15098, #14150) + // IE throws on elements created in popups + // FF meanwhile throws on frame elements through + // "defaultView.getComputedStyle" + var view = elem.ownerDocument.defaultView; + + if (!view || !view.opener) { + view = window; + } + + return view.getComputedStyle(elem); + }; + + curCSS = function(elem, name, computed) { + var width, minWidth, maxWidth, ret, style = elem.style; + + computed = computed || getStyles(elem); + + // getPropertyValue is only needed for + // .css('filter') in IE9, see #12537 + ret = computed ? computed.getPropertyValue(name) || computed[name] : undefined; + + // Support: Opera 12.1x only + // Fall back to style even without computed + // computed is undefined for elems on document + // fragments + if ((ret === "" || ret === undefined) && !jQuery.contains(elem.ownerDocument, elem)) { + ret = jQuery.style(elem, name); + } + + if (computed) { + + // A tribute to the "awesome hack by Dean + // Edwards" + // Chrome < 17 and Safari 5.0 uses "computed + // value" + // instead of "used value" for margin-right + // Safari 5.1.7 (at least) returns percentage + // for a larger set of values, + // but width seems to be reliably pixels + // this is against the CSSOM draft spec: + // http://dev.w3.org/csswg/cssom/#resolved-values + if (!support.pixelMarginRight() && rnumnonpx.test(ret) && rmargin.test(name)) { + + // Remember the original values + width = style.width; + minWidth = style.minWidth; + maxWidth = style.maxWidth; + + // Put in the new values to get a computed + // value out + style.minWidth = style.maxWidth = style.width = ret; + ret = computed.width; + + // Revert the changed values + style.width = width; + style.minWidth = minWidth; + style.maxWidth = maxWidth; + } + } + + // Support: IE + // IE returns zIndex value as an integer. + return ret === undefined ? ret : ret + ""; + }; + } else if (documentElement.currentStyle) { + getStyles = function(elem) { + return elem.currentStyle; + }; + + curCSS = function(elem, name, computed) { + var left, rs, rsLeft, ret, style = elem.style; + + computed = computed || getStyles(elem); + ret = computed ? computed[name] : undefined; + + // Avoid setting ret to empty string here + // so we don't default to auto + if (ret == null && style && style[name]) { + ret = style[name]; + } + + // 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 + // but not position css attributes, as those are + // proportional to the parent element instead + // and we can't measure the parent instead because + // it + // might trigger a "stacking dolls" problem + if (rnumnonpx.test(ret) && !rposition.test(name)) { + + // Remember the original values + left = style.left; + rs = elem.runtimeStyle; + rsLeft = rs && rs.left; + + // Put in the new values to get a computed value + // out + if (rsLeft) { + rs.left = elem.currentStyle.left; + } + style.left = name === "fontSize" ? "1em" : ret; + ret = style.pixelLeft + "px"; + + // Revert the changed values + style.left = left; + if (rsLeft) { + rs.left = rsLeft; + } + } + + // Support: IE + // IE returns zIndex value as an integer. + return ret === undefined ? ret : ret + "" || "auto"; + }; + } + + function addGetHookIf(conditionFn, hookFn) { + + // Define the hook, we'll check on the first run if it's + // really needed. + return { + get : function() { + if (conditionFn()) { + + // Hook not needed (or it's not possible to + // use it due + // to missing dependency), remove it. + delete this.get; + return; + } + + // Hook needed; redefine it so that the support + // test is not executed again. + return (this.get = hookFn).apply(this, arguments); + } + }; + } + + var + + ralpha = /alpha\([^)]*\)/i, ropacity = /opacity\s*=\s*([^)]*)/i, + + // swappable if display is none or starts with table except + // "table", "table-cell", or "table-caption" + // see here for display values: + // https://developer.mozilla.org/en-US/docs/CSS/display + rdisplayswap = /^(none|table(?!-c[ea]).+)/, rnumsplit = new RegExp("^(" + pnum + ")(.*)$", "i"), + + cssShow = { + position : "absolute", + visibility : "hidden", + display : "block" + }, cssNormalTransform = { + letterSpacing : "0", + fontWeight : "400" + }, + + cssPrefixes = [ "Webkit", "O", "Moz", "ms" ], emptyStyle = document.createElement("div").style; + + // return a css property mapped to a potentially vendor + // prefixed property + function vendorPropName(name) { + + // shortcut for names that are not vendor prefixed + if (name in emptyStyle) { + return name; + } + + // check for vendor prefixed names + var capName = name.charAt(0).toUpperCase() + name.slice(1), i = cssPrefixes.length; + + while (i--) { + name = cssPrefixes[i] + capName; + if (name in emptyStyle) { + return name; + } + } + } + + function showHide(elements, show) { + var display, elem, hidden, values = [], index = 0, length = elements.length; + + for (; index < length; index++) { + elem = elements[index]; + if (!elem.style) { + continue; + } + + values[index] = jQuery._data(elem, "olddisplay"); + display = elem.style.display; + if (show) { + + // Reset the inline display of this element to + // learn if it is + // being hidden by cascaded rules or not + if (!values[index] && display === "none") { + 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 (elem.style.display === "" && isHidden(elem)) { + values[index] = jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName)); + } + } else { + hidden = isHidden(elem); + + if (display && display !== "none" || !hidden) { + jQuery._data(elem, "olddisplay", hidden ? display : jQuery.css(elem, "display")); + } + } + } + + // Set the display of most of the elements in a second + // loop + // to avoid the constant reflow + for (index = 0; index < length; index++) { + elem = elements[index]; + if (!elem.style) { + continue; + } + if (!show || elem.style.display === "none" || elem.style.display === "") { + elem.style.display = show ? values[index] || "" : "none"; + } + } + + return elements; + } + + function setPositiveNumber(elem, value, subtract) { + var matches = rnumsplit.exec(value); + return matches ? + + // Guard against undefined "subtract", e.g., when used + // as in cssHooks + Math.max(0, matches[1] - (subtract || 0)) + (matches[2] || "px") : value; + } + + function augmentWidthOrHeight(elem, name, extra, isBorderBox, styles) { + var i = extra === (isBorderBox ? "border" : "content") ? + + // If we already have the right measurement, avoid + // augmentation + 4 : + + // Otherwise initialize for horizontal or vertical + // properties + name === "width" ? 1 : 0, + + val = 0; + + for (; i < 4; i += 2) { + + // both box models exclude margin, so add it if we + // want it + if (extra === "margin") { + val += jQuery.css(elem, extra + cssExpand[i], true, styles); + } + + if (isBorderBox) { + + // border-box includes padding, so remove it if + // we want content + if (extra === "content") { + val -= jQuery.css(elem, "padding" + cssExpand[i], true, styles); + } + + // at this point, extra isn't border nor margin, + // so remove border + if (extra !== "margin") { + val -= jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles); + } + } else { + + // at this point, extra isn't content, so add + // padding + val += jQuery.css(elem, "padding" + cssExpand[i], true, styles); + + // at this point, extra isn't content nor + // padding, so add border + if (extra !== "padding") { + val += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles); + } + } + } + + return val; + } + + function getWidthOrHeight(elem, name, extra) { + + // Start with offset property, which is equivalent to + // the border-box value + var valueIsBorderBox = true, val = name === "width" ? elem.offsetWidth : elem.offsetHeight, styles = getStyles(elem), isBorderBox = support.boxSizing + && jQuery.css(elem, "boxSizing", false, styles) === "border-box"; + + // some non-html elements return undefined for + // offsetWidth, so check for null/undefined + // svg - + // https://bugzilla.mozilla.org/show_bug.cgi?id=649285 + // MathML - + // https://bugzilla.mozilla.org/show_bug.cgi?id=491668 + if (val <= 0 || val == null) { + + // Fall back to computed then uncomputed css if + // necessary + val = curCSS(elem, name, styles); + if (val < 0 || val == null) { + val = elem.style[name]; + } + + // Computed unit is not pixels. Stop here and + // return. + if (rnumnonpx.test(val)) { + return val; + } + + // we need the check for style in case a browser + // which returns unreliable values + // for getComputedStyle silently falls back to the + // reliable elem.style + valueIsBorderBox = isBorderBox && (support.boxSizingReliable() || val === elem.style[name]); + + // Normalize "", auto, and prepare for extra + val = parseFloat(val) || 0; + } + + // use the active box-sizing model to add/subtract + // irrelevant styles + return (val + augmentWidthOrHeight(elem, name, extra || (isBorderBox ? "border" : "content"), + valueIsBorderBox, styles)) + + "px"; + } + + 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; + } + } + } + }, + + // Don't automatically add "px" to these + // possibly-unitless properties + cssNumber : { + "animationIterationCount" : true, + "columnCount" : true, + "fillOpacity" : true, + "flexGrow" : true, + "flexShrink" : true, + "fontWeight" : true, + "lineHeight" : true, + "opacity" : true, + "order" : 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" : 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, hooks, origName = jQuery.camelCase(name), style = elem.style; + + name = jQuery.cssProps[origName] + || (jQuery.cssProps[origName] = vendorPropName(origName) || origName); + + // gets hook for the prefixed version + // followed by the unprefixed version + hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName]; + + // Check if we're setting a value + if (value !== undefined) { + type = typeof value; + + // Convert "+=" or "-=" to relative + // numbers (#7345) + if (type === "string" && (ret = rcssNum.exec(value)) && ret[1]) { + value = adjustCSS(elem, name, ret); + + // Fixes bug #9237 + type = "number"; + } + + // Make sure that null and NaN values + // aren't set. See: #7116 + if (value == null || value !== value) { + return; + } + + // If a number was passed in, add the + // unit (except for certain CSS + // properties) + if (type === "number") { + value += ret && ret[3] || (jQuery.cssNumber[origName] ? "" : "px"); + } + + // Fixes #8908, it can be done more + // correctly by specifing setters in + // cssHooks, + // but it would mean to define eight + // (for every problematic property) + // identical functions + if (!support.clearCloneStyle && value === "" && name.indexOf("background") === 0) { + style[name] = "inherit"; + } + + // If a hook was provided, use that + // value, otherwise just set the + // specified value + if (!hooks || !("set" in hooks) + || (value = hooks.set(elem, value, extra)) !== undefined) { + + // Support: IE + // Swallow errors from 'invalid' CSS + // values (#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, styles) { + var num, val, hooks, origName = jQuery.camelCase(name); + + // Make sure that we're working with the + // right name + name = jQuery.cssProps[origName] + || (jQuery.cssProps[origName] = vendorPropName(origName) || origName); + + // gets hook for the prefixed version + // followed by the unprefixed version + hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName]; + + // If a hook was provided get the computed + // value from there + if (hooks && "get" in hooks) { + val = hooks.get(elem, true, extra); + } + + // Otherwise, if a way to get the computed + // value exists, use that + if (val === undefined) { + val = curCSS(elem, name, styles); + } + + // convert "normal" to computed value + if (val === "normal" && name in cssNormalTransform) { + val = cssNormalTransform[name]; + } + + // Return, converting to number if forced or + // a qualifier was provided and val looks + // numeric + if (extra === "" || extra) { + num = parseFloat(val); + return extra === true || isFinite(num) ? num || 0 : val; + } + return val; + } + }); + + jQuery + .each( + [ "height", "width" ], + function(i, name) { + jQuery.cssHooks[name] = { + get : function(elem, computed, extra) { + if (computed) { + + // certain elements can have + // dimension info if we + // invisibly show them + // however, it must have a + // current display style + // that would benefit from + // this + return rdisplayswap.test(jQuery.css(elem, "display")) + && elem.offsetWidth === 0 ? swap(elem, cssShow, function() { + return getWidthOrHeight(elem, name, extra); + }) : getWidthOrHeight(elem, name, extra); + } + }, + + set : function(elem, value, extra) { + var styles = extra && getStyles(elem); + return setPositiveNumber( + elem, + value, + extra ? augmentWidthOrHeight( + elem, + name, + extra, + support.boxSizing + && jQuery.css(elem, "boxSizing", false, styles) === "border-box", + styles) + : 0); + } + }; + }); + + if (!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) + || "") ? (0.01 * parseFloat(RegExp.$1)) + "" : 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 === "", then remove inline opacity + // #12685 + if ((value >= 1 || value === "") && jQuery.trim(filter.replace(ralpha, "")) === "" + && style.removeAttribute) { + + // 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 is no filter style applied in a + // css rule + // or unset inline opacity, we are done + if (value === "" || currentStyle && !currentStyle.filter) { + return; + } + } + + // otherwise, set new filter values + style.filter = ralpha.test(filter) ? filter.replace(ralpha, opacity) : filter + " " + + opacity; + } + }; + } + + jQuery.cssHooks.marginRight = addGetHookIf(support.reliableMarginRight, function(elem, computed) { + if (computed) { + return swap(elem, { + "display" : "inline-block" + }, curCSS, [ elem, "marginRight" ]); + } + }); + + jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function(elem, computed) { + if (computed) { + return (parseFloat(curCSS(elem, "marginLeft")) || + + // Support: IE<=11+ + // Running getBoundingClientRect on a + // disconnected node in IE throws an error + // Support: IE8 only + // getClientRects() errors on disconnected + // elems + (jQuery.contains(elem.ownerDocument, elem) ? elem.getBoundingClientRect().left + - swap(elem, { + marginLeft : 0 + }, function() { + return elem.getBoundingClientRect().left; + }) : 0)) + + "px"; + } + }); + + // 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 = 0, expanded = {}, + + // assumes a single number if + // not a string + parts = typeof value === "string" ? value.split(" ") : [ value ]; + + for (; i < 4; i++) { + expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0]; + } + + return expanded; + } + }; + + if (!rmargin.test(prefix)) { + jQuery.cssHooks[prefix + suffix].set = setPositiveNumber; + } + }); + + jQuery.fn.extend({ + css : function(name, value) { + return access(this, function(elem, name, value) { + var styles, len, map = {}, i = 0; + + if (jQuery.isArray(name)) { + styles = getStyles(elem); + len = name.length; + + for (; i < len; i++) { + map[name[i]] = jQuery.css(elem, name[i], false, styles); + } + + return map; + } + + return value !== undefined ? jQuery.style(elem, name, value) : jQuery.css(elem, name); + }, name, value, arguments.length > 1); + }, + show : function() { + return showHide(this, true); + }, + hide : function() { + return showHide(this); + }, + toggle : function(state) { + if (typeof state === "boolean") { + return state ? this.show() : this.hide(); + } + + return this.each(function() { + if (isHidden(this)) { + jQuery(this).show(); + } else { + jQuery(this).hide(); + } + }); + } + }); + + function Tween(elem, options, prop, end, easing) { + return new Tween.prototype.init(elem, options, prop, end, easing); + } + jQuery.Tween = Tween; + + Tween.prototype = { + constructor : Tween, + init : function(elem, options, prop, end, easing, unit) { + this.elem = elem; + this.prop = prop; + this.easing = easing || jQuery.easing._default; + this.options = options; + this.start = this.now = this.cur(); + this.end = end; + this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px"); + }, + cur : function() { + var hooks = Tween.propHooks[this.prop]; + + return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this); + }, + run : function(percent) { + var eased, hooks = Tween.propHooks[this.prop]; + + if (this.options.duration) { + this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, + 0, 1, this.options.duration); + } else { + this.pos = eased = percent; + } + this.now = (this.end - this.start) * eased + this.start; + + if (this.options.step) { + this.options.step.call(this.elem, this.now, this); + } + + if (hooks && hooks.set) { + hooks.set(this); + } else { + Tween.propHooks._default.set(this); + } + return this; + } + }; + + Tween.prototype.init.prototype = Tween.prototype; + + Tween.propHooks = { + _default : { + get : function(tween) { + var result; + + // Use a property on the element directly when + // it is not a DOM element, + // or when there is no matching style property + // that exists. + if (tween.elem.nodeType !== 1 || tween.elem[tween.prop] != null + && tween.elem.style[tween.prop] == null) { + return tween.elem[tween.prop]; + } + + // passing an empty string as a 3rd parameter to + // .css will automatically + // attempt a parseFloat and fallback to a string + // if the parse fails + // so, simple values such as "10px" are parsed + // to Float. + // complex values such as "rotate(1rad)" are + // returned as is. + result = jQuery.css(tween.elem, tween.prop, ""); + + // Empty strings, null, undefined and "auto" are + // converted to 0. + return !result || result === "auto" ? 0 : result; + }, + set : function(tween) { + + // use step hook for back compat - use cssHook + // if its there - use .style if its + // available and use plain properties where + // available + if (jQuery.fx.step[tween.prop]) { + jQuery.fx.step[tween.prop](tween); + } else if (tween.elem.nodeType === 1 + && (tween.elem.style[jQuery.cssProps[tween.prop]] != null || jQuery.cssHooks[tween.prop])) { + jQuery.style(tween.elem, tween.prop, tween.now + tween.unit); + } else { + tween.elem[tween.prop] = tween.now; + } + } + } + }; + + // Support: IE <=9 + // Panic based approach to setting things on disconnected + // nodes + + Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { + set : function(tween) { + if (tween.elem.nodeType && tween.elem.parentNode) { + tween.elem[tween.prop] = tween.now; + } + } + }; + + jQuery.easing = { + linear : function(p) { + return p; + }, + swing : function(p) { + return 0.5 - Math.cos(p * Math.PI) / 2; + }, + _default : "swing" + }; + + jQuery.fx = Tween.prototype.init; + + // Back Compat <1.8 extension point + jQuery.fx.step = {}; + + var fxNow, timerId, rfxtypes = /^(?:toggle|show|hide)$/, rrun = /queueHooks$/; + + // Animations created synchronously will run synchronously + function createFxNow() { + window.setTimeout(function() { + fxNow = undefined; + }); + return (fxNow = jQuery.now()); + } + + // Generate parameters to create a standard animation + function genFx(type, includeWidth) { + var which, attrs = { + height : type + }, i = 0; + + // if we include width, step value is 1 to do all + // cssExpand values, + // if we don't include width, step value is 2 to skip + // over Left and Right + includeWidth = includeWidth ? 1 : 0; + for (; i < 4; i += 2 - includeWidth) { + which = cssExpand[i]; + attrs["margin" + which] = attrs["padding" + which] = type; + } + + if (includeWidth) { + attrs.opacity = attrs.width = type; + } + + return attrs; + } + + function createTween(value, prop, animation) { + var tween, collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners["*"]), index = 0, length = collection.length; + for (; index < length; index++) { + if ((tween = collection[index].call(animation, prop, value))) { + + // we're done with this property + return tween; + } + } + } + + function defaultPrefilter(elem, props, opts) { + /* jshint validthis: true */ + var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay, anim = this, orig = {}, style = elem.style, hidden = elem.nodeType + && isHidden(elem), dataShow = jQuery._data(elem, "fxshow"); + + // handle queue: false promises + if (!opts.queue) { + hooks = jQuery._queueHooks(elem, "fx"); + if (hooks.unqueued == null) { + hooks.unqueued = 0; + oldfire = hooks.empty.fire; + hooks.empty.fire = function() { + if (!hooks.unqueued) { + oldfire(); + } + }; + } + hooks.unqueued++; + + anim.always(function() { + + // doing this makes sure that the complete + // handler will be called + // before this completes + anim.always(function() { + hooks.unqueued--; + if (!jQuery.queue(elem, "fx").length) { + hooks.empty.fire(); + } + }); + }); + } + + // height/width overflow pass + if (elem.nodeType === 1 && ("height" in props || "width" in props)) { + + // 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 + opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; + + // Set display property to inline-block for + // height/width + // animations on inline elements that are having + // width/height animated + display = jQuery.css(elem, "display"); + + // Test default display if display is currently + // "none" + checkDisplay = display === "none" ? jQuery._data(elem, "olddisplay") + || defaultDisplay(elem.nodeName) : display; + + if (checkDisplay === "inline" && jQuery.css(elem, "float") === "none") { + + // inline-level elements accept inline-block; + // block-level elements need to be inline with + // layout + if (!support.inlineBlockNeedsLayout || defaultDisplay(elem.nodeName) === "inline") { + style.display = "inline-block"; + } else { + style.zoom = 1; + } + } + } + + if (opts.overflow) { + style.overflow = "hidden"; + if (!support.shrinkWrapBlocks()) { + anim.always(function() { + style.overflow = opts.overflow[0]; + style.overflowX = opts.overflow[1]; + style.overflowY = opts.overflow[2]; + }); + } + } + + // show/hide pass + for (prop in props) { + value = props[prop]; + if (rfxtypes.exec(value)) { + delete props[prop]; + toggle = toggle || value === "toggle"; + if (value === (hidden ? "hide" : "show")) { + + // If there is dataShow left over from a + // stopped hide or show + // and we are going to proceed with show, we + // should pretend to be hidden + if (value === "show" && dataShow && dataShow[prop] !== undefined) { + hidden = true; + } else { + continue; + } + } + orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop); + + // Any non-fx value stops us from restoring the + // original display value + } else { + display = undefined; + } + } + + if (!jQuery.isEmptyObject(orig)) { + if (dataShow) { + if ("hidden" in dataShow) { + hidden = dataShow.hidden; + } + } else { + dataShow = jQuery._data(elem, "fxshow", {}); + } + + // store state if its toggle - enables + // .stop().toggle() to "reverse" + if (toggle) { + dataShow.hidden = !hidden; + } + if (hidden) { + jQuery(elem).show(); + } else { + anim.done(function() { + jQuery(elem).hide(); + }); + } + anim.done(function() { + var prop; + jQuery._removeData(elem, "fxshow"); + for (prop in orig) { + jQuery.style(elem, prop, orig[prop]); + } + }); + for (prop in orig) { + tween = createTween(hidden ? dataShow[prop] : 0, prop, anim); + + if (!(prop in dataShow)) { + dataShow[prop] = tween.start; + if (hidden) { + tween.end = tween.start; + tween.start = prop === "width" || prop === "height" ? 1 : 0; + } + } + } + + // If this is a noop like .hide().hide(), restore an + // overwritten display value + } else if ((display === "none" ? defaultDisplay(elem.nodeName) : display) === "inline") { + style.display = display; + } + } + + function propFilter(props, specialEasing) { + var index, name, easing, value, hooks; + + // camelCase, specialEasing and expand cssHook pass + for (index in props) { + name = jQuery.camelCase(index); + easing = specialEasing[name]; + value = props[index]; + if (jQuery.isArray(value)) { + easing = value[1]; + value = props[index] = value[0]; + } + + if (index !== name) { + props[name] = value; + delete props[index]; + } + + hooks = jQuery.cssHooks[name]; + if (hooks && "expand" in hooks) { + value = hooks.expand(value); + delete props[name]; + + // not quite $.extend, this wont overwrite keys + // already present. + // also - reusing 'index' from above because we + // have the correct "name" + for (index in value) { + if (!(index in props)) { + props[index] = value[index]; + specialEasing[index] = easing; + } + } + } else { + specialEasing[name] = easing; + } + } + } + + function Animation(elem, properties, options) { + var result, stopped, index = 0, length = Animation.prefilters.length, deferred = jQuery + .Deferred().always(function() { + + // don't match elem in the :animated + // selector + delete tick.elem; + }), tick = function() { + if (stopped) { + return false; + } + var currentTime = fxNow || createFxNow(), remaining = Math.max(0, animation.startTime + + animation.duration - currentTime), + + // Support: Android 2.3 + // Archaic crash bug won't allow us to use `1 - ( + // 0.5 || 0 )` (#12497) + temp = remaining / animation.duration || 0, percent = 1 - temp, index = 0, length = animation.tweens.length; + + for (; index < length; index++) { + animation.tweens[index].run(percent); + } + + deferred.notifyWith(elem, [ animation, percent, remaining ]); + + if (percent < 1 && length) { + return remaining; + } else { + deferred.resolveWith(elem, [ animation ]); + return false; + } + }, animation = deferred.promise({ + elem : elem, + props : jQuery.extend({}, properties), + opts : jQuery.extend(true, { + specialEasing : {}, + easing : jQuery.easing._default + }, options), + originalProperties : properties, + originalOptions : options, + startTime : fxNow || createFxNow(), + duration : options.duration, + tweens : [], + createTween : function(prop, end) { + var tween = jQuery.Tween(elem, animation.opts, prop, end, + animation.opts.specialEasing[prop] || animation.opts.easing); + animation.tweens.push(tween); + return tween; + }, + stop : function(gotoEnd) { + var index = 0, + + // if we are going to the end, we want to run + // all the tweens + // otherwise we skip this part + length = gotoEnd ? animation.tweens.length : 0; + if (stopped) { + return this; + } + stopped = true; + for (; index < length; index++) { + animation.tweens[index].run(1); + } + + // resolve when we played the last frame + // otherwise, reject + if (gotoEnd) { + deferred.notifyWith(elem, [ animation, 1, 0 ]); + deferred.resolveWith(elem, [ animation, gotoEnd ]); + } else { + deferred.rejectWith(elem, [ animation, gotoEnd ]); + } + return this; + } + }), props = animation.props; + + propFilter(props, animation.opts.specialEasing); + + for (; index < length; index++) { + result = Animation.prefilters[index].call(animation, elem, props, animation.opts); + if (result) { + if (jQuery.isFunction(result.stop)) { + jQuery._queueHooks(animation.elem, animation.opts.queue).stop = jQuery.proxy( + result.stop, result); + } + return result; + } + } + + jQuery.map(props, createTween, animation); + + if (jQuery.isFunction(animation.opts.start)) { + animation.opts.start.call(elem, animation); + } + + jQuery.fx.timer(jQuery.extend(tick, { + elem : elem, + anim : animation, + queue : animation.opts.queue + })); + + // attach callbacks from options + return animation.progress(animation.opts.progress).done(animation.opts.done, + animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always); + } + + jQuery.Animation = jQuery.extend(Animation, { + + tweeners : { + "*" : [ function(prop, value) { + var tween = this.createTween(prop, value); + adjustCSS(tween.elem, prop, rcssNum.exec(value), tween); + return tween; + } ] + }, + + tweener : function(props, callback) { + if (jQuery.isFunction(props)) { + callback = props; + props = [ "*" ]; + } else { + props = props.match(rnotwhite); + } + + var prop, index = 0, length = props.length; + + for (; index < length; index++) { + prop = props[index]; + Animation.tweeners[prop] = Animation.tweeners[prop] || []; + Animation.tweeners[prop].unshift(callback); + } + }, + + prefilters : [ defaultPrefilter ], + + prefilter : function(callback, prepend) { + if (prepend) { + Animation.prefilters.unshift(callback); + } else { + Animation.prefilters.push(callback); + } + } + }); + + jQuery.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() { + if (jQuery.isFunction(opt.old)) { + opt.old.call(this); + } + + if (opt.queue) { + jQuery.dequeue(this, opt.queue); + } + }; + + return opt; + }; + + jQuery.fn + .extend({ + fadeTo : function(speed, to, easing, callback) { + + // show any hidden elements after setting + // opacity to 0 + return this.filter(isHidden).css("opacity", 0).show() + + // animate to the value specified + .end().animate({ + opacity : to + }, speed, easing, callback); + }, + animate : function(prop, speed, easing, callback) { + var empty = jQuery.isEmptyObject(prop), optall = jQuery.speed(speed, easing, + callback), doAnimation = function() { + + // Operate on a copy of prop so + // per-property easing won't be lost + var anim = Animation(this, jQuery.extend({}, prop), optall); + + // Empty animations, or finishing + // resolves immediately + if (empty || jQuery._data(this, "finish")) { + anim.stop(true); + } + }; + doAnimation.finish = doAnimation; + + return empty || optall.queue === false ? this.each(doAnimation) : this.queue( + optall.queue, doAnimation); + }, + stop : function(type, clearQueue, gotoEnd) { + var stopQueue = function(hooks) { + var stop = hooks.stop; + delete hooks.stop; + stop(gotoEnd); + }; + + if (typeof type !== "string") { + gotoEnd = clearQueue; + clearQueue = type; + type = undefined; + } + if (clearQueue && type !== false) { + this.queue(type || "fx", []); + } + + return this + .each(function() { + var dequeue = true, index = type != null && type + "queueHooks", timers = jQuery.timers, data = jQuery + ._data(this); + + if (index) { + if (data[index] && data[index].stop) { + stopQueue(data[index]); + } + } else { + for (index in data) { + if (data[index] && data[index].stop && rrun.test(index)) { + stopQueue(data[index]); + } + } + } + + for (index = timers.length; index--;) { + if (timers[index].elem === this + && (type == null || timers[index].queue === type)) { + + timers[index].anim.stop(gotoEnd); + dequeue = false; + 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 (dequeue || !gotoEnd) { + jQuery.dequeue(this, type); + } + }); + }, + finish : function(type) { + if (type !== false) { + type = type || "fx"; + } + return this + .each(function() { + var index, data = jQuery._data(this), queue = data[type + "queue"], hooks = data[type + + "queueHooks"], timers = jQuery.timers, length = queue ? queue.length + : 0; + + // enable finishing flag on + // private data + data.finish = true; + + // empty the queue first + jQuery.queue(this, type, []); + + if (hooks && hooks.stop) { + hooks.stop.call(this, true); + } + + // look for any active + // animations, and finish them + for (index = timers.length; index--;) { + if (timers[index].elem === this && timers[index].queue === type) { + timers[index].anim.stop(true); + timers.splice(index, 1); + } + } + + // look for any animations in + // the old queue and finish them + for (index = 0; index < length; index++) { + if (queue[index] && queue[index].finish) { + queue[index].finish.call(this); + } + } + + // turn off finishing flag + delete data.finish; + }); + } + }); + + jQuery.each([ "toggle", "show", "hide" ], function(i, name) { + var cssFn = jQuery.fn[name]; + jQuery.fn[name] = function(speed, easing, callback) { + return speed == null || typeof speed === "boolean" ? cssFn.apply(this, arguments) : this + .animate(genFx(name, true), speed, easing, callback); + }; + }); + + // Generate shortcuts for custom animations + jQuery.each({ + slideDown : genFx("show"), + slideUp : genFx("hide"), + slideToggle : genFx("toggle"), + 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.timers = []; + jQuery.fx.tick = function() { + var timer, timers = jQuery.timers, i = 0; + + fxNow = jQuery.now(); + + 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(); + } + fxNow = undefined; + }; + + jQuery.fx.timer = function(timer) { + jQuery.timers.push(timer); + if (timer()) { + jQuery.fx.start(); + } else { + jQuery.timers.pop(); + } + }; + + jQuery.fx.interval = 13; + + jQuery.fx.start = function() { + if (!timerId) { + timerId = window.setInterval(jQuery.fx.tick, jQuery.fx.interval); + } + }; + + jQuery.fx.stop = function() { + window.clearInterval(timerId); + timerId = null; + }; + + jQuery.fx.speeds = { + slow : 600, + fast : 200, + + // Default speed + _default : 400 + }; + + // Based off of the plugin by Clint Helfers, with + // permission. + // http://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ + jQuery.fn.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 = window.setTimeout(next, time); + hooks.stop = function() { + window.clearTimeout(timeout); + }; + }); + }; + + (function() { + var a, input = document.createElement("input"), div = document.createElement("div"), select = document + .createElement("select"), opt = select.appendChild(document.createElement("option")); + + // Setup + div = document.createElement("div"); + div.setAttribute("className", "t"); + div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; + a = div.getElementsByTagName("a")[0]; + + // Support: Windows Web Apps (WWA) + // `type` must use .setAttribute for WWA (#14901) + input.setAttribute("type", "checkbox"); + div.appendChild(input); + + a = div.getElementsByTagName("a")[0]; + + // First batch of tests. + a.style.cssText = "top:1px"; + + // Test setAttribute on camelCase class. + // If it works, we need attrFixes when doing + // get/setAttribute (ie6/7) + support.getSetAttribute = div.className !== "t"; + + // Get the style information from getAttribute + // (IE uses .cssText instead) + support.style = /top/.test(a.getAttribute("style")); + + // Make sure that URLs aren't manipulated + // (IE normalizes it by default) + support.hrefNormalized = a.getAttribute("href") === "/a"; + + // Check the default checkbox/radio value ("" on WebKit; + // "on" elsewhere) + support.checkOn = !!input.value; + + // 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) + support.optSelected = opt.selected; + + // Tests for enctype support on a form (#6743) + support.enctype = !!document.createElement("form").enctype; + + // 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; + + // Support: IE8 only + // Check if we can trust getAttribute("value") + input = document.createElement("input"); + input.setAttribute("value", ""); + support.input = input.getAttribute("value") === ""; + + // Check if an input maintains its value after becoming + // a radio + input.value = "t"; + input.setAttribute("type", "radio"); + support.radioValue = input.value === "t"; + })(); + + var rreturn = /\r/g, rspaces = /[\x20\t\r\n\f]+/g; + + jQuery.fn.extend({ + 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 val; + + if (this.nodeType !== 1) { + return; + } + + if (isFunction) { + val = value.call(this, i, jQuery(this).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) { + var val = jQuery.find.attr(elem, "value"); + return val != null ? val : + + // Support: IE10-11+ + // option.text throws exceptions + // (#14686, #14858) + // Strip and collapse whitespace + // https://html.spec.whatwg.org/#strip-and-collapse-whitespace + jQuery.trim(jQuery.text(elem)).replace(rspaces, " "); + } + }, + select : { + get : function(elem) { + var value, option, options = elem.options, index = elem.selectedIndex, one = elem.type === "select-one" + || index < 0, values = one ? null : [], max = one ? index + 1 + : options.length, i = index < 0 ? max : one ? index : 0; + + // Loop through all the selected + // options + for (; i < max; i++) { + option = options[i]; + + // oldIE doesn't update selected + // after form reset (#2551) + if ((option.selected || i === index) + && + + // Don't return options + // that are disabled or + // in a disabled + // optgroup + (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); + } + } + + return values; + }, + + set : function(elem, value) { + var optionSet, option, options = elem.options, values = jQuery + .makeArray(value), i = options.length; + + while (i--) { + option = options[i]; + + if (jQuery.inArray(jQuery.valHooks.option.get(option), values) > -1) { + + // Support: IE6 + // When new option element + // is added to select box we + // need to + // force reflow of newly + // added node in order to + // workaround delay + // of initialization + // properties + try { + option.selected = optionSet = true; + + } catch (_) { + + // Will be executed only + // in IE6 + option.scrollHeight; + } + + } else { + option.selected = false; + } + } + + // Force browsers to behave + // consistently when non-matching + // value is set + if (!optionSet) { + elem.selectedIndex = -1; + } + + return options; + } + } + } + }); + + // Radios and checkboxes getter/setter + jQuery.each([ "radio", "checkbox" ], function() { + jQuery.valHooks[this] = { + set : function(elem, value) { + if (jQuery.isArray(value)) { + return (elem.checked = jQuery.inArray(jQuery(elem).val(), value) > -1); + } + } + }; + if (!support.checkOn) { + jQuery.valHooks[this].get = function(elem) { + return elem.getAttribute("value") === null ? "on" : elem.value; + }; + } + }); + + var nodeHook, boolHook, attrHandle = jQuery.expr.attrHandle, ruseDefault = /^(?:checked|selected)$/i, getSetAttribute = support.getSetAttribute, getSetInput = support.input; + + jQuery.fn.extend({ + attr : function(name, value) { + return access(this, jQuery.attr, name, value, arguments.length > 1); + }, + + removeAttr : function(name) { + return this.each(function() { + jQuery.removeAttr(this, name); + }); + } + }); + + jQuery.extend({ + attr : function(elem, name, value) { + var ret, hooks, nType = elem.nodeType; + + // Don't get/set attributes on text, comment + // and attribute nodes + if (nType === 3 || nType === 8 || nType === 2) { + return; + } + + // Fallback to prop when attributes are not + // supported + if (typeof elem.getAttribute === "undefined") { + return jQuery.prop(elem, name, value); + } + + // All attributes are lowercase + // Grab necessary hook if one is defined + if (nType !== 1 || !jQuery.isXMLDoc(elem)) { + name = name.toLowerCase(); + hooks = jQuery.attrHooks[name] + || (jQuery.expr.match.bool.test(name) ? boolHook : nodeHook); + } + + if (value !== undefined) { + if (value === null) { + jQuery.removeAttr(elem, name); + return; + } + + if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) { + return ret; + } + + elem.setAttribute(name, value + ""); + return value; + } + + if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) { + return ret; + } + + ret = jQuery.find.attr(elem, name); + + // Non-existent attributes return null, we + // normalize to undefined + return ret == null ? undefined : ret; + }, + + attrHooks : { + type : { + set : function(elem, value) { + if (!support.radioValue && value === "radio" && jQuery.nodeName(elem, "input")) { + + // Setting the type on a radio + // button after the value resets + // the value in IE8-9 + // Reset value to default in + // case type is set after value + // during creation + var val = elem.value; + elem.setAttribute("type", value); + if (val) { + elem.value = val; + } + return value; + } + } + } + }, + + removeAttr : function(elem, value) { + var name, propName, i = 0, attrNames = value && value.match(rnotwhite); + + if (attrNames && elem.nodeType === 1) { + while ((name = attrNames[i++])) { + propName = jQuery.propFix[name] || name; + + // Boolean attributes get special + // treatment (#10870) + if (jQuery.expr.match.bool.test(name)) { + + // Set corresponding property to + // false + if (getSetInput && getSetAttribute || !ruseDefault.test(name)) { + elem[propName] = false; + + // Support: IE<9 + // Also clear + // defaultChecked/defaultSelected + // (if appropriate) + } else { + elem[jQuery.camelCase("default-" + name)] = elem[propName] = false; + } + + // See #9699 for explanation of + // this approach (setting first, + // then removal) + } else { + jQuery.attr(elem, name, ""); + } + + elem.removeAttribute(getSetAttribute ? name : propName); + } + } + } + }); + + // Hooks for boolean attributes + boolHook = { + set : function(elem, value, name) { + if (value === false) { + + // Remove boolean attributes when set to false + jQuery.removeAttr(elem, name); + } else if (getSetInput && getSetAttribute || !ruseDefault.test(name)) { + + // IE<8 needs the *property* name + elem.setAttribute(!getSetAttribute && jQuery.propFix[name] || name, name); + + } else { + + // Support: IE<9 + // Use defaultChecked and defaultSelected for + // oldIE + elem[jQuery.camelCase("default-" + name)] = elem[name] = true; + } + return name; + } + }; + + jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function(i, name) { + var getter = attrHandle[name] || jQuery.find.attr; + + if (getSetInput && getSetAttribute || !ruseDefault.test(name)) { + attrHandle[name] = function(elem, name, isXML) { + var ret, handle; + if (!isXML) { + + // Avoid an infinite loop by + // temporarily removing this + // function from the getter + handle = attrHandle[name]; + attrHandle[name] = ret; + ret = getter(elem, name, isXML) != null ? name.toLowerCase() : null; + attrHandle[name] = handle; + } + return ret; + }; + } else { + attrHandle[name] = function(elem, name, isXML) { + if (!isXML) { + return elem[jQuery.camelCase("default-" + name)] ? name.toLowerCase() : null; + } + }; + } + }); + + // fix oldIE attroperties + if (!getSetInput || !getSetAttribute) { + jQuery.attrHooks.value = { + set : function(elem, value, name) { + if (jQuery.nodeName(elem, "input")) { + + // Does not return so that setAttribute is + // also used + elem.defaultValue = value; + } else { + + // Use nodeHook if defined (#1954); + // otherwise setAttribute is fine + return nodeHook && nodeHook.set(elem, value, name); + } + } + }; + } + + // IE6/7 do not support getting/setting some attributes with + // get/setAttribute + if (!getSetAttribute) { + + // Use this for any attribute in IE6/7 + // This fixes almost every IE6/7 issue + nodeHook = { + set : function(elem, value, name) { + + // Set the existing or create a new attribute + // node + var ret = elem.getAttributeNode(name); + if (!ret) { + elem.setAttributeNode((ret = elem.ownerDocument.createAttribute(name))); + } + + ret.value = value += ""; + + // Break association with cloned elements by + // also using setAttribute (#9646) + if (name === "value" || value === elem.getAttribute(name)) { + return value; + } + } + }; + + // Some attributes are constructed with empty-string + // values when not defined + attrHandle.id = attrHandle.name = attrHandle.coords = function(elem, name, isXML) { + var ret; + if (!isXML) { + return (ret = elem.getAttributeNode(name)) && ret.value !== "" ? ret.value : null; + } + }; + + // Fixing value retrieval on a button requires this + // module + jQuery.valHooks.button = { + get : function(elem, name) { + var ret = elem.getAttributeNode(name); + if (ret && ret.specified) { + return ret.value; + } + }, + set : nodeHook.set + }; + + // Set contenteditable to false on removals(#10429) + // Setting to empty string throws an error as an invalid + // value + jQuery.attrHooks.contenteditable = { + set : function(elem, value, name) { + nodeHook.set(elem, value === "" ? false : value, name); + } + }; + + // 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] = { + set : function(elem, value) { + if (value === "") { + elem.setAttribute(name, "auto"); + return value; + } + } + }; + }); + } + + if (!support.style) { + jQuery.attrHooks.style = { + get : function(elem) { + + // Return undefined in the case of empty string + // Note: IE uppercases css property names, but + // if we were to .toLowerCase() + // .cssText, that would destroy case sensitivity + // in URL's, like in "background" + return elem.style.cssText || undefined; + }, + set : function(elem, value) { + return (elem.style.cssText = value + ""); + } + }; + } + + var rfocusable = /^(?:input|select|textarea|button|object)$/i, rclickable = /^(?:a|area)$/i; + + jQuery.fn.extend({ + prop : function(name, value) { + return 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) { + } + }); + } + }); + + jQuery.extend({ + prop : function(elem, name, value) { + var ret, hooks, nType = elem.nodeType; + + // Don't get/set properties on text, comment + // and attribute nodes + if (nType === 3 || nType === 8 || nType === 2) { + return; + } + + if (nType !== 1 || !jQuery.isXMLDoc(elem)) { + + // 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; + } + + return (elem[name] = value); + } + + if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) { + return ret; + } + + 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/ + // Use proper attribute + // retrieval(#12072) + var tabindex = jQuery.find.attr(elem, "tabindex"); + + return tabindex ? parseInt(tabindex, 10) : rfocusable.test(elem.nodeName) + || rclickable.test(elem.nodeName) && elem.href ? 0 : -1; + } + } + }, + + propFix : { + "for" : "htmlFor", + "class" : "className" + } + }); + + // Some attributes require a special call on IE + // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx + if (!support.hrefNormalized) { + + // href/src property should get the full normalized URL + // (#10299/#12915) + jQuery.each([ "href", "src" ], function(i, name) { + jQuery.propHooks[name] = { + get : function(elem) { + return elem.getAttribute(name, 4); + } + }; + }); + } + + // Support: Safari, IE9+ + // Accessing the selectedIndex property + // forces the browser to respect setting selected + // on the option + // The getter ensures a default option is selected + // when in an optgroup + if (!support.optSelected) { + 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; + }, + set : function(elem) { + var parent = elem.parentNode; + if (parent) { + parent.selectedIndex; + + if (parent.parentNode) { + parent.parentNode.selectedIndex; + } + } + } + }; + } + + jQuery.each([ "tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", + "colSpan", "useMap", "frameBorder", "contentEditable" ], function() { + jQuery.propFix[this.toLowerCase()] = this; + }); + + // IE6/7 call enctype encoding + if (!support.enctype) { + jQuery.propFix.enctype = "encoding"; + } + + var rclass = /[\t\r\n\f]/g; + + function getClass(elem) { + return jQuery.attr(elem, "class") || ""; + } + + jQuery.fn.extend({ + addClass : function(value) { + var classes, elem, cur, curValue, clazz, j, finalValue, i = 0; + + if (jQuery.isFunction(value)) { + return this.each(function(j) { + jQuery(this).addClass(value.call(this, j, getClass(this))); + }); + } + + if (typeof value === "string" && value) { + classes = value.match(rnotwhite) || []; + + while ((elem = this[i++])) { + curValue = getClass(elem); + cur = elem.nodeType === 1 && (" " + curValue + " ").replace(rclass, " "); + + if (cur) { + j = 0; + while ((clazz = classes[j++])) { + if (cur.indexOf(" " + clazz + " ") < 0) { + cur += clazz + " "; + } + } + + // only assign if different to + // avoid unneeded rendering. + finalValue = jQuery.trim(cur); + if (curValue !== finalValue) { + jQuery.attr(elem, "class", finalValue); + } + } + } + } + + return this; + }, + + removeClass : function(value) { + var classes, elem, cur, curValue, clazz, j, finalValue, i = 0; + + if (jQuery.isFunction(value)) { + return this.each(function(j) { + jQuery(this).removeClass(value.call(this, j, getClass(this))); + }); + } + + if (!arguments.length) { + return this.attr("class", ""); + } + + if (typeof value === "string" && value) { + classes = value.match(rnotwhite) || []; + + while ((elem = this[i++])) { + curValue = getClass(elem); + + // This expression is here for + // better compressibility (see + // addClass) + cur = elem.nodeType === 1 && (" " + curValue + " ").replace(rclass, " "); + + if (cur) { + j = 0; + while ((clazz = classes[j++])) { + + // Remove *all* instances + while (cur.indexOf(" " + clazz + " ") > -1) { + cur = cur.replace(" " + clazz + " ", " "); + } + } + + // Only assign if different to + // avoid unneeded rendering. + finalValue = jQuery.trim(cur); + if (curValue !== finalValue) { + jQuery.attr(elem, "class", finalValue); + } + } + } + } + + return this; + }, + + toggleClass : function(value, stateVal) { + var type = typeof value; + + if (typeof stateVal === "boolean" && type === "string") { + return stateVal ? this.addClass(value) : this.removeClass(value); + } + + if (jQuery.isFunction(value)) { + return this.each(function(i) { + jQuery(this).toggleClass(value.call(this, i, getClass(this), stateVal), stateVal); + }); + } + + return this.each(function() { + var className, i, self, classNames; + + if (type === "string") { + + // Toggle individual class + // names + i = 0; + self = jQuery(this); + classNames = value.match(rnotwhite) || []; + + while ((className = classNames[i++])) { + + // Check each className + // given, space + // separated list + if (self.hasClass(className)) { + self.removeClass(className); + } else { + self.addClass(className); + } + } + + // Toggle whole class name + } else if (value === undefined || type === "boolean") { + className = getClass(this); + if (className) { + + // store className if + // set + jQuery._data(this, "__className__", className); + } + + // If the element has a + // class name or if we're + // passed "false", + // then remove the whole + // classname (if there was + // one, the above saved it). + // Otherwise bring back + // whatever was previously + // saved (if anything), + // falling back to the empty + // string if nothing was + // stored. + jQuery.attr(this, "class", className || value === false ? "" : jQuery._data(this, + "__className__") + || ""); + } + }); + }, + + hasClass : function(selector) { + var className, elem, i = 0; + + className = " " + selector + " "; + while ((elem = this[i++])) { + if (elem.nodeType === 1 + && (" " + getClass(elem) + " ").replace(rclass, " ").indexOf(className) > -1) { + return true; + } + } + + return false; + } + }); + + // Return jQuery for attributes-only inclusion + + 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) { + return arguments.length > 0 ? this.on(name, null, data, fn) : this.trigger(name); + }; + }); + + jQuery.fn.extend({ + hover : function(fnOver, fnOut) { + return this.mouseenter(fnOver).mouseleave(fnOut || fnOver); + } + }); + + var location = window.location; + + var nonce = jQuery.now(); + + var rquery = (/\?/); + + var rvalidtokens = /(,)|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/g; + + jQuery.parseJSON = function(data) { + + // Attempt to parse using the native JSON parser first + if (window.JSON && window.JSON.parse) { + + // Support: Android 2.3 + // Workaround failure to string-cast null input + return window.JSON.parse(data + ""); + } + + var requireNonComma, depth = null, str = jQuery.trim(data + ""); + + // Guard against invalid (and possibly dangerous) input + // by ensuring that nothing remains + // after removing valid tokens + return str && !jQuery.trim(str.replace(rvalidtokens, function(token, comma, open, close) { + + // Force termination if we see a + // misplaced comma + if (requireNonComma && comma) { + depth = 0; + } + + // Perform no more replacements + // after returning to outermost + // depth + if (depth === 0) { + return token; + } + + // Commas must not follow "[", "{", + // or "," + requireNonComma = open || comma; + + // Determine new depth + // array/object open ("[" or "{"): + // depth += true - false (increment) + // array/object close ("]" or "}"): + // depth += false - true (decrement) + // other cases ("," or primitive): + // depth += true - true (numeric + // cast) + depth += !close - !open; + + // Remove this token + return ""; + })) ? (Function("return " + str))() : jQuery.error("Invalid JSON: " + data); + }; + + // Cross-browser xml parsing + jQuery.parseXML = function(data) { + var xml, tmp; + if (!data || typeof data !== "string") { + return null; + } + try { + if (window.DOMParser) { // Standard + tmp = new window.DOMParser(); + xml = tmp.parseFromString(data, "text/xml"); + } else { // IE + xml = new window.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; + }; + + var rhash = /#.*$/, rts = /([?&])_=[^&]*/, + + // IE leaves an \r character at EOL + rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, + + // #7653, #8125, #8152: local protocol detection + rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, rnoContent = /^(?:GET|HEAD)$/, rprotocol = /^\/\//, rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/, + + /* + * 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 = {}, + + // Avoid comment-prolog char sequence (#10098); must appease + // lint and evade compression + allTypes = "*/".concat("*"), + + // Document location + ajaxLocation = location.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 = "*"; + } + + var dataType, i = 0, dataTypes = dataTypeExpression.toLowerCase().match(rnotwhite) || []; + + if (jQuery.isFunction(func)) { + + // For each dataType in the dataTypeExpression + while ((dataType = dataTypes[i++])) { + + // Prepend if requested + if (dataType.charAt(0) === "+") { + dataType = dataType.slice(1) || "*"; + (structure[dataType] = structure[dataType] || []).unshift(func); + + // Otherwise append + } else { + (structure[dataType] = structure[dataType] || []).push(func); + } + } + } + }; + } + + // Base inspection function for prefilters and transports + function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) { + + var inspected = {}, seekingTransport = (structure === transports); + + function inspect(dataType) { + var selected; + inspected[dataType] = true; + jQuery.each(structure[dataType] || [], function(_, prefilterOrFactory) { + var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR); + if (typeof dataTypeOrTransport === "string" && !seekingTransport + && !inspected[dataTypeOrTransport]) { + + options.dataTypes.unshift(dataTypeOrTransport); + inspect(dataTypeOrTransport); + return false; + } else if (seekingTransport) { + return !(selected = dataTypeOrTransport); + } + }); + return selected; + } + + return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*"); + } + + // A special extend for ajax options + // that takes "flat" options (not to be deep extended) + // Fixes #9887 + function ajaxExtend(target, src) { + var deep, key, 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); + } + + return target; + } + + /* + * Handles responses to an ajax request: - finds the right + * dataType (mediates between content-type and expected + * dataType) - returns the corresponding response + */ + function ajaxHandleResponses(s, jqXHR, responses) { + var firstDataType, ct, finalDataType, type, contents = s.contents, dataTypes = s.dataTypes; + + // 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 Also sets the responseXXX fields on the jqXHR + * instance + */ + function ajaxConvert(s, response, jqXHR, isSuccess) { + var conv2, current, conv, tmp, prev, converters = {}, + + // Work with a copy of dataTypes in case we need to + // modify it for conversion + dataTypes = s.dataTypes.slice(); + + // Create converters map with lowercased keys + if (dataTypes[1]) { + for (conv in s.converters) { + converters[conv.toLowerCase()] = s.converters[conv]; + } + } + + current = dataTypes.shift(); + + // Convert to each sequential dataType + while (current) { + + if (s.responseFields[current]) { + jqXHR[s.responseFields[current]] = response; + } + + // Apply the dataFilter if provided + if (!prev && isSuccess && s.dataFilter) { + response = s.dataFilter(response, s.dataType); + } + + prev = current; + current = dataTypes.shift(); + + if (current) { + + // There's only work to do if current dataType + // is non-auto + if (current === "*") { + + current = prev; + + // Convert response if prev dataType is + // non-auto and differs from current + } else if (prev !== "*" && prev !== current) { + + // Seek a direct converter + conv = converters[prev + " " + current] || converters["* " + current]; + + // If none found, seek a pair + if (!conv) { + for (conv2 in converters) { + + // If conv2 outputs current + tmp = conv2.split(" "); + if (tmp[1] === current) { + + // If prev can be converted to + // accepted input + conv = converters[prev + " " + tmp[0]] || converters["* " + tmp[0]]; + if (conv) { + + // Condense equivalence + // converters + if (conv === true) { + conv = converters[conv2]; + + // Otherwise, insert the + // intermediate dataType + } else if (converters[conv2] !== true) { + current = tmp[0]; + dataTypes.unshift(tmp[1]); + } + break; + } + } + } + } + + // Apply converter (if not an equivalence) + if (conv !== true) { + + // Unless errors are allowed to bubble, + // catch and return them + if (conv && s["throws"]) { // jscs:ignore + // requireDotNotation + response = conv(response); + } else { + try { + response = conv(response); + } catch (e) { + return { + state : "parsererror", + error : conv ? e : "No conversion from " + prev + " to " + current + }; + } + } + } + } + } + } + + return { + state : "success", + data : response + }; + } + + jQuery + .extend({ + + // Counter for holding the number of active + // queries + active : 0, + + // Last-Modified header cache for next request + lastModified : {}, + etag : {}, + + ajaxSettings : { + url : ajaxLocation, + type : "GET", + isLocal : rlocalProtocol.test(ajaxLocParts[1]), + global : true, + processData : true, + async : true, + contentType : "application/x-www-form-urlencoded; charset=UTF-8", + /* + * timeout: 0, data: null, dataType: null, + * username: null, password: null, cache: + * null, throws: false, traditional: false, + * headers: {}, + */ + + accepts : { + "*" : allTypes, + text : "text/plain", + html : "text/html", + xml : "application/xml, text/xml", + json : "application/json, text/javascript" + }, + + contents : { + xml : /\bxml\b/, + html : /\bhtml/, + json : /\bjson\b/ + }, + + responseFields : { + xml : "responseXML", + text : "responseText", + json : "responseJSON" + }, + + // Data converters + // Keys separate source (or catchall "*") + // and destination types with a single space + converters : { + + // Convert anything to text + "* text" : 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 : { + url : true, + context : true + } + }, + + // 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) { + return settings ? + + // Building a settings object + ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) : + + // Extending ajaxSettings + ajaxExtend(jQuery.ajaxSettings, target); + }, + + 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 + + // Cross-domain detection vars + parts, + + // Loop variable + i, + + // URL without anti-cache param + cacheURL, + + // Response headers as string + responseHeadersString, + + // timeout handle + timeoutTimer, + + // To know if global events are to be + // dispatched + fireGlobals, + + transport, + + // Response headers + responseHeaders, + + // Create the final options object + s = jQuery.ajaxSetup({}, options), + + // Callbacks context + callbackContext = s.context || s, + + // Context for global events is + // callbackContext if it is a DOM node or + // jQuery collection + globalEventContext = s.context + && (callbackContext.nodeType || callbackContext.jquery) ? jQuery(callbackContext) + : jQuery.event, + + // Deferreds + deferred = jQuery.Deferred(), completeDeferred = jQuery.Callbacks("once memory"), + + // Status-dependent callbacks + statusCode = s.statusCode || {}, + + // Headers (they are sent all at once) + requestHeaders = {}, requestHeadersNames = {}, + + // The jqXHR state + state = 0, + + // Default abort message + strAbort = "canceled", + + // Fake xhr + jqXHR = { + readyState : 0, + + // 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 == null ? null : match; + }, + + // Raw string + getAllResponseHeaders : function() { + return state === 2 ? responseHeadersString : null; + }, + + // Caches the header + setRequestHeader : function(name, value) { + var lname = name.toLowerCase(); + if (!state) { + name = requestHeadersNames[lname] = requestHeadersNames[lname] || name; + requestHeaders[name] = value; + } + return this; + }, + + // Overrides response content-type + // header + overrideMimeType : function(type) { + if (!state) { + s.mimeType = type; + } + return this; + }, + + // Status-dependent callbacks + statusCode : function(map) { + var code; + if (map) { + if (state < 2) { + for (code in map) { + + // Lazy-add the new + // callback in a way + // that preserves old + // ones + statusCode[code] = [ statusCode[code], map[code] ]; + } + } else { + + // Execute the appropriate + // callbacks + jqXHR.always(map[jqXHR.status]); + } + } + return this; + }, + + // Cancel the request + abort : function(statusText) { + var finalText = statusText || strAbort; + if (transport) { + transport.abort(finalText); + } + done(0, finalText); + return this; + } + }; + + // Attach deferreds + deferred.promise(jqXHR).complete = completeDeferred.add; + jqXHR.success = jqXHR.done; + jqXHR.error = jqXHR.fail; + + // Remove hash character (#7531: and string + // promotion) + // Add protocol if not provided (#5866: IE7 + // issue with protocol-less urls) + // Handle falsy url in the settings object + // (#10093: consistency with old signature) + // We also use the url parameter if + // available + s.url = ((url || s.url || ajaxLocation) + "").replace(rhash, "").replace(rprotocol, + ajaxLocParts[1] + "//"); + + // Alias method option to type as per ticket + // #12004 + s.type = options.method || options.type || s.method || s.type; + + // Extract dataTypes list + s.dataTypes = jQuery.trim(s.dataType || "*").toLowerCase().match(rnotwhite) + || [ "" ]; + + // A cross-domain request is in order when + // we have a protocol:host:port mismatch + 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 jqXHR; + } + + // We can fire global events as of now if + // asked to + // Don't fire events if jQuery.event is + // undefined in an AMD-usage scenario + // (#15118) + fireGlobals = jQuery.event && s.global; + + // Watch for a new set of requests + if (fireGlobals && jQuery.active++ === 0) { + jQuery.event.trigger("ajaxStart"); + } + + // Uppercase the type + s.type = s.type.toUpperCase(); + + // Determine if request has content + s.hasContent = !rnoContent.test(s.type); + + // Save the URL in case we're toying with + // the If-Modified-Since + // and/or If-None-Match header later on + cacheURL = s.url; + + // More options handling for requests with + // no content + if (!s.hasContent) { + + // If data is available, append data to + // url + if (s.data) { + cacheURL = (s.url += (rquery.test(cacheURL) ? "&" : "?") + s.data); + + // #9682: remove data so that it's + // not used in an eventual retry + delete s.data; + } + + // Add anti-cache in url if needed + if (s.cache === false) { + s.url = rts.test(cacheURL) ? + + // If there is already a '_' + // parameter, set its value + cacheURL.replace(rts, "$1_=" + nonce++) : + + // Otherwise add one to the + // end + cacheURL + (rquery.test(cacheURL) ? "&" : "?") + "_=" + nonce++; + } + } + + // Set the If-Modified-Since and/or + // If-None-Match header, if in ifModified + // mode. + if (s.ifModified) { + if (jQuery.lastModified[cacheURL]) { + jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]); + } + if (jQuery.etag[cacheURL]) { + jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL]); + } + } + + // 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 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 and return + return jqXHR.abort(); + } + + // aborting is no longer a cancellation + strAbort = "abort"; + + // 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 ]); + } + + // If request was aborted inside + // ajaxSend, stop there + if (state === 2) { + return jqXHR; + } + + // Timeout + if (s.async && s.timeout > 0) { + timeoutTimer = window.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; + } + } + } + + // Callback for when everything is done + function done(status, nativeStatusText, responses, headers) { + var isSuccess, success, error, response, modified, statusText = nativeStatusText; + + // Called once + if (state === 2) { + return; + } + + // State is "done" now + state = 2; + + // Clear timeout if it exists + if (timeoutTimer) { + window.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; + + // Determine if successful + isSuccess = status >= 200 && status < 300 || status === 304; + + // Get response data + if (responses) { + response = ajaxHandleResponses(s, jqXHR, responses); + } + + // Convert no matter what (that way + // responseXXX fields are always set) + response = ajaxConvert(s, response, jqXHR, isSuccess); + + // If successful, handle type chaining + if (isSuccess) { + + // Set the If-Modified-Since and/or + // If-None-Match header, if in + // ifModified mode. + if (s.ifModified) { + modified = jqXHR.getResponseHeader("Last-Modified"); + if (modified) { + jQuery.lastModified[cacheURL] = modified; + } + modified = jqXHR.getResponseHeader("etag"); + if (modified) { + jQuery.etag[cacheURL] = modified; + } + } + + // if no content + if (status === 204 || s.type === "HEAD") { + statusText = "nocontent"; + + // if not modified + } else if (status === 304) { + statusText = "notmodified"; + + // If we have data, let's + // convert it + } else { + statusText = response.state; + success = response.data; + error = response.error; + isSuccess = !error; + } + } else { + + // We extract error from statusText + // then normalize statusText and + // status for non-aborts + error = statusText; + if (status || !statusText) { + 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(isSuccess ? "ajaxSuccess" : "ajaxError", [ + 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"); + } + } + } + + return jqXHR; + }, + + getJSON : function(url, data, callback) { + return jQuery.get(url, data, callback, "json"); + }, + + getScript : function(url, callback) { + return jQuery.get(url, undefined, callback, "script"); + } + }); + + 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; + } + + // The url can be an options object (which then must + // have .url) + return jQuery.ajax(jQuery.extend({ + url : url, + type : method, + dataType : type, + data : data, + success : callback + }, jQuery.isPlainObject(url) && url)); + }; + }); + + jQuery._evalUrl = function(url) { + return jQuery.ajax({ + url : url, + + // Make this explicit, since user can override this + // through ajaxSetup (#11264) + type : "GET", + dataType : "script", + cache : true, + async : false, + global : false, + "throws" : true + }); + }; + + jQuery.fn.extend({ + 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(); + } + }); + + function getDisplay(elem) { + return elem.style && elem.style.display || jQuery.css(elem, "display"); + } + + function filterHidden(elem) { + + // Disconnected elements are considered hidden + if (!jQuery.contains(elem.ownerDocument || document, elem)) { + return true; + } + while (elem && elem.nodeType === 1) { + if (getDisplay(elem) === "none" || elem.type === "hidden") { + return true; + } + elem = elem.parentNode; + } + return false; + } + + jQuery.expr.filters.hidden = function(elem) { + + // Support: Opera <= 12.12 + // Opera reports offsetWidths and offsetHeights less + // than zero on some elements + return support.reliableHiddenOffsets() ? (elem.offsetWidth <= 0 && elem.offsetHeight <= 0 && !elem + .getClientRects().length) + : filterHidden(elem); + }; + + jQuery.expr.filters.visible = function(elem) { + return !jQuery.expr.filters.hidden(elem); + }; + + var r20 = /%20/g, rbracket = /\[\]$/, rCRLF = /\r?\n/g, rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, rsubmittable = /^(?:input|select|textarea|keygen)/i; + + function buildParams(prefix, obj, traditional, add) { + var name; + + 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 { + + // Item is non-scalar (array or object), + // encode its numeric index. + buildParams(prefix + "[" + (typeof v === "object" && v != null ? i : "") + "]", v, + traditional, add); + } + }); + + } else if (!traditional && jQuery.type(obj) === "object") { + + // Serialize object item. + for (name in obj) { + buildParams(prefix + "[" + name + "]", obj[name], traditional, add); + } + + } else { + + // Serialize scalar item. + add(prefix, obj); + } + } + + // Serialize an array of form elements or a set of + // key/values into a query string + jQuery.param = function(a, traditional) { + var prefix, s = [], add = function(key, value) { + + // If value is a function, invoke it and return its + // value + value = jQuery.isFunction(value) ? value() : (value == null ? "" : value); + s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value); + }; + + // Set traditional to true for jQuery <= 1.3.2 behavior. + if (traditional === undefined) { + traditional = jQuery.ajaxSettings && 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 (prefix in a) { + buildParams(prefix, a[prefix], traditional, add); + } + } + + // Return the resulting serialization + return s.join("&").replace(r20, "+"); + }; + + jQuery.fn.extend({ + serialize : function() { + return jQuery.param(this.serializeArray()); + }, + serializeArray : function() { + return this.map(function() { + + // Can add propHook for + // "elements" to filter + // or add form elements + var elements = jQuery.prop(this, "elements"); + return elements ? jQuery.makeArray(elements) : this; + }).filter( + function() { + var type = this.type; + + // Use .is(":disabled") + // so that + // fieldset[disabled] + // works + return this.name && !jQuery(this).is(":disabled") + && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) + && (this.checked || !rcheckableType.test(type)); + }).map(function(i, elem) { + var val = jQuery(this).val(); + + return val == null ? null : jQuery.isArray(val) ? jQuery.map(val, function(val) { + return { + name : elem.name, + value : val.replace(rCRLF, "\r\n") + }; + }) : { + name : elem.name, + value : val.replace(rCRLF, "\r\n") + }; + }).get(); + } + }); + + // Create the request object + // (This is still attached to ajaxSettings for backward + // compatibility) + jQuery.ajaxSettings.xhr = window.ActiveXObject !== undefined ? + + // Support: IE6-IE8 + function() { + + // XHR cannot access local files, always use ActiveX for + // that case + if (this.isLocal) { + return createActiveXHR(); + } + + // Support: IE 9-11 + // IE seems to error on cross-domain PATCH requests when + // ActiveX XHR + // is used. In IE 9+ always use the native XHR. + // Note: this condition won't catch Edge as it doesn't + // define + // document.documentMode but it also doesn't support + // ActiveX so it won't + // reach this code. + if (document.documentMode > 8) { + return createStandardXHR(); + } + + // Support: IE<9 + // oldIE XHR does not support non-RFC2616 methods + // (#13240) + // See + // http://msdn.microsoft.com/en-us/library/ie/ms536648(v=vs.85).aspx + // and + // http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9 + // Although this check for six methods instead of eight + // since IE also does not support "trace" and "connect" + return /^(get|post|head|put|delete|options)$/i.test(this.type) && createStandardXHR() + || createActiveXHR(); + } : + + // For all other browsers, use the standard + // XMLHttpRequest object + createStandardXHR; + + var xhrId = 0, xhrCallbacks = {}, xhrSupported = jQuery.ajaxSettings.xhr(); + + // Support: IE<10 + // Open requests must be manually aborted on unload (#5280) + // See https://support.microsoft.com/kb/2856746 for more + // info + if (window.attachEvent) { + window.attachEvent("onunload", function() { + for ( var key in xhrCallbacks) { + xhrCallbacks[key](undefined, true); + } + }); + } + + // Determine support properties + support.cors = !!xhrSupported && ("withCredentials" in xhrSupported); + xhrSupported = support.ajax = !!xhrSupported; + + // Create transport if the browser can provide an xhr + if (xhrSupported) { + + jQuery.ajaxTransport(function(options) { + + // Cross domain only allowed if supported + // through XMLHttpRequest + if (!options.crossDomain || support.cors) { + + var callback; + + return { + send : function(headers, complete) { + var i, xhr = options.xhr(), id = ++xhrId; + + // Open the socket + xhr.open(options.type, options.url, options.async, options.username, + options.password); + + // Apply custom fields if + // provided + if (options.xhrFields) { + for (i in options.xhrFields) { + xhr[i] = options.xhrFields[i]; + } + } + + // Override mime type if needed + if (options.mimeType && xhr.overrideMimeType) { + xhr.overrideMimeType(options.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 (!options.crossDomain && !headers["X-Requested-With"]) { + headers["X-Requested-With"] = "XMLHttpRequest"; + } + + // Set headers + for (i in headers) { + + // Support: IE<9 + // IE's ActiveXObject throws + // a 'Type Mismatch' + // exception when setting + // request header to a + // null-value. + // + // To keep consistent with + // other XHR + // implementations, cast the + // value + // to string and ignore + // `undefined`. + if (headers[i] !== undefined) { + xhr.setRequestHeader(i, headers[i] + ""); + } + } + + // Do send the request + // This may raise an exception + // which is actually + // handled in jQuery.ajax (so no + // try/catch here) + xhr.send((options.hasContent && options.data) || null); + + // Listener + callback = function(_, isAbort) { + var status, statusText, responses; + + // Was never called and is + // aborted or complete + if (callback && (isAbort || xhr.readyState === 4)) { + + // Clean up + delete xhrCallbacks[id]; + callback = undefined; + xhr.onreadystatechange = jQuery.noop; + + // Abort manually if + // needed + if (isAbort) { + if (xhr.readyState !== 4) { + xhr.abort(); + } + } else { + responses = {}; + status = xhr.status; + + // Support: IE<10 + // Accessing + // binary-data + // responseText + // throws an + // exception + // (#11426) + if (typeof xhr.responseText === "string") { + responses.text = xhr.responseText; + } + + // 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 && options.isLocal && !options.crossDomain) { + status = responses.text ? 200 : 404; + + // IE - #1450: + // sometimes + // returns 1223 + // when it + // should be 204 + } else if (status === 1223) { + status = 204; + } + } + } + + // Call complete if needed + if (responses) { + complete(status, statusText, responses, xhr.getAllResponseHeaders()); + } + }; + + // Do send the request + // `xhr.send` may raise an + // exception, but it will be + // handled in jQuery.ajax (so no + // try/catch here) + if (!options.async) { + + // If we're in sync mode we + // fire the callback + callback(); + } else if (xhr.readyState === 4) { + + // (IE6 & IE7) if it's in + // cache and has been + // retrieved directly we + // need to fire the callback + window.setTimeout(callback); + } else { + + // Register the callback, + // but delay it in case + // `xhr.send` throws + // Add to the list of active + // xhr callbacks + xhr.onreadystatechange = xhrCallbacks[id] = callback; + } + }, + + abort : function() { + if (callback) { + callback(undefined, true); + } + } + }; + } + }); + } + + // Functions to create xhrs + function createStandardXHR() { + try { + return new window.XMLHttpRequest(); + } catch (e) { + } + } + + function createActiveXHR() { + try { + return new window.ActiveXObject("Microsoft.XMLHTTP"); + } catch (e) { + } + } + + // Install script dataType + jQuery.ajaxSetup({ + accepts : { + script : "text/javascript, application/javascript, " + + "application/ecmascript, application/x-ecmascript" + }, + contents : { + script : /\b(?:java|ecma)script\b/ + }, + 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 || jQuery("head")[0] || document.documentElement; + + return { + + send : function(_, callback) { + + script = document.createElement("script"); + + script.async = true; + + 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 (script.parentNode) { + script.parentNode.removeChild(script); + } + + // Dereference the + // script + script = null; + + // Callback if not + // abort + if (!isAbort) { + callback(200, "success"); + } + } + }; + + // Circumvent IE6 bugs with + // base elements (#2709 and + // #4378) by prepending + // Use native DOM + // manipulation to avoid our + // domManip AJAX trickery + head.insertBefore(script, head.firstChild); + }, + + abort : function() { + if (script) { + script.onload(undefined, true); + } + } + }; + } + }); + + var oldCallbacks = [], rjsonp = /(=)\?(?=&|$)|\?\?/; + + // Default jsonp settings + jQuery.ajaxSetup({ + jsonp : "callback", + jsonpCallback : function() { + var callback = oldCallbacks.pop() || (jQuery.expando + "_" + (nonce++)); + this[callback] = true; + return callback; + } + }); + + // Detect, normalize options and install callbacks for jsonp + // requests + jQuery.ajaxPrefilter("json jsonp", function(s, originalSettings, jqXHR) { + + var callbackName, overwritten, responseContainer, jsonProp = s.jsonp !== false + && (rjsonp.test(s.url) ? "url" : typeof s.data === "string" + && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0 + && rjsonp.test(s.data) && "data"); + + // Handle iff the expected data type is + // "jsonp" or we have a parameter to set + if (jsonProp || s.dataTypes[0] === "jsonp") { + + // Get callback name, remembering + // preexisting value associated with + // it + callbackName = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback) ? s.jsonpCallback() + : s.jsonpCallback; + + // Insert callback into url or form + // data + if (jsonProp) { + s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName); + } else if (s.jsonp !== false) { + s.url += (rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName; + } + + // Use data converter to retrieve + // json after script execution + s.converters["script json"] = function() { + if (!responseContainer) { + jQuery.error(callbackName + " was not called"); + } + return responseContainer[0]; + }; + + // force json dataType + s.dataTypes[0] = "json"; + + // Install callback + overwritten = window[callbackName]; + window[callbackName] = function() { + responseContainer = arguments; + }; + + // Clean-up function (fires after + // converters) + jqXHR.always(function() { + + // If previous value + // didn't exist - remove + // it + if (overwritten === undefined) { + jQuery(window).removeProp(callbackName); + + // Otherwise restore + // preexisting value + } else { + window[callbackName] = overwritten; + } + + // Save back as free + if (s[callbackName]) { + + // make sure that + // re-using the + // options doesn't + // screw things + // around + s.jsonpCallback = originalSettings.jsonpCallback; + + // save the callback + // name for future + // use + oldCallbacks.push(callbackName); + } + + // Call if it was a + // function and we have + // a response + if (responseContainer && jQuery.isFunction(overwritten)) { + overwritten(responseContainer[0]); + } + + responseContainer = overwritten = undefined; + }); + + // Delegate to script + return "script"; + } + }); + + // data: string of html + // context (optional): If specified, the fragment will be + // created in this context, + // defaults to document + // keepScripts (optional): If true, will include scripts + // passed in the html string + jQuery.parseHTML = function(data, context, keepScripts) { + if (!data || typeof data !== "string") { + return null; + } + if (typeof context === "boolean") { + keepScripts = context; + context = false; + } + context = context || document; + + var parsed = rsingleTag.exec(data), scripts = !keepScripts && []; + + // Single tag + if (parsed) { + return [ context.createElement(parsed[1]) ]; + } + + parsed = buildFragment([ data ], context, scripts); + + if (scripts && scripts.length) { + jQuery(scripts).remove(); + } + + return jQuery.merge([], parsed.childNodes); + }; + + // Keep a copy of the old load method + var _load = jQuery.fn.load; + + /** + * Load a url into a page + */ + jQuery.fn.load = function(url, params, callback) { + if (typeof url !== "string" && _load) { + return _load.apply(this, arguments); + } + + var selector, type, response, self = this, off = url.indexOf(" "); + + if (off > -1) { + selector = jQuery.trim(url.slice(off, url.length)); + url = url.slice(0, off); + } + + // 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 (params && typeof params === "object") { + type = "POST"; + } + + // If we have elements to modify, make the request + if (self.length > 0) { + jQuery.ajax({ + url : url, + + // If "type" variable is undefined, then + // "GET" method will be used. + // Make value of this field explicit + // since + // user can override it through + // ajaxSetup method + type : type || "GET", + dataType : "html", + data : params + }).done(function(responseText) { + + // Save response for use in + // complete callback + response = arguments; + + self.html(selector ? + + // If a selector was + // specified, locate the + // right elements in a + // dummy div + // Exclude scripts to + // avoid IE 'Permission + // Denied' errors + jQuery("<div>").append(jQuery.parseHTML(responseText)).find(selector) : + + // Otherwise use + // the full + // result + responseText); + + // If the request succeeds, this + // function gets "data", + // "status", "jqXHR" + // but they are ignored because + // response was set above. + // If it fails, this function + // gets "jqXHR", "status", + // "error" + }).always(callback && function(jqXHR, status) { + self.each(function() { + callback.apply(this, response || [ jqXHR.responseText, status, jqXHR ]); + }); + }); + } + + return this; + }; + + // Attach a bunch of functions for handling common AJAX + // events + jQuery.each([ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], + function(i, type) { + jQuery.fn[type] = function(fn) { + return this.on(type, fn); + }; + }); + + jQuery.expr.filters.animated = function(elem) { + return jQuery.grep(jQuery.timers, function(fn) { + return elem === fn.elem; + }).length; + }; + + /** + * Gets a window from an element + */ + function getWindow(elem) { + return jQuery.isWindow(elem) ? elem : elem.nodeType === 9 ? elem.defaultView + || elem.parentWindow : false; + } + + jQuery.offset = { + setOffset : function(elem, options, i) { + var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, position = jQuery + .css(elem, "position"), curElem = jQuery(elem), props = {}; + + // set position first, in-case top/left are set even + // on static elem + if (position === "static") { + elem.style.position = "relative"; + } + + curOffset = curElem.offset(); + curCSSTop = jQuery.css(elem, "top"); + curCSSLeft = jQuery.css(elem, "left"); + calculatePosition = (position === "absolute" || position === "fixed") + && jQuery.inArray("auto", [ curCSSTop, curCSSLeft ]) > -1; + + // 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)) { + + // Use jQuery.extend here to allow modification + // of coordinates argument (gh-1848) + options = options.call(elem, i, jQuery.extend({}, 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({ + offset : function(options) { + if (arguments.length) { + return options === undefined ? this : this.each(function(i) { + jQuery.offset.setOffset(this, options, i); + }); + } + + var docElem, win, box = { + top : 0, + left : 0 + }, elem = this[0], doc = elem && elem.ownerDocument; + + if (!doc) { + return; + } + + docElem = doc.documentElement; + + // Make sure it's not a disconnected DOM + // node + if (!jQuery.contains(docElem, elem)) { + return box; + } + + // If we don't have gBCR, just use 0,0 + // rather than error + // BlackBerry 5, iOS 3 (original iPhone) + if (typeof elem.getBoundingClientRect !== "undefined") { + box = elem.getBoundingClientRect(); + } + win = getWindow(doc); + return { + top : box.top + (win.pageYOffset || docElem.scrollTop) - (docElem.clientTop || 0), + left : box.left + (win.pageXOffset || docElem.scrollLeft) - (docElem.clientLeft || 0) + }; + }, + + position : function() { + if (!this[0]) { + return; + } + + var offsetParent, offset, parentOffset = { + top : 0, + left : 0 + }, elem = this[0]; + + // Fixed elements are offset from window + // (parentOffset = {top:0, left: 0}, + // because it is its only offset parent + if (jQuery.css(elem, "position") === "fixed") { + + // we assume that getBoundingClientRect + // is available when computed position + // is fixed + offset = elem.getBoundingClientRect(); + } else { + + // Get *real* offsetParent + offsetParent = this.offsetParent(); + + // Get correct offsets + offset = this.offset(); + if (!jQuery.nodeName(offsetParent[0], "html")) { + parentOffset = offsetParent.offset(); + } + + // Add offsetParent borders + parentOffset.top += jQuery.css(offsetParent[0], "borderTopWidth", true); + parentOffset.left += jQuery.css(offsetParent[0], "borderLeftWidth", true); + } + + // Subtract parent offsets and 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 + return { + top : offset.top - parentOffset.top - jQuery.css(elem, "marginTop", true), + left : offset.left - parentOffset.left - jQuery.css(elem, "marginLeft", true) + }; + }, + + offsetParent : function() { + return this.map(function() { + var offsetParent = this.offsetParent; + + while (offsetParent + && (!jQuery.nodeName(offsetParent, "html") && jQuery.css(offsetParent, + "position") === "static")) { + offsetParent = offsetParent.offsetParent; + } + return offsetParent || documentElement; + }); + } + }); + + // 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 access(this, function(elem, method, val) { + var win = getWindow(elem); + + if (val === undefined) { + return win ? (prop in win) ? win[prop] : win.document.documentElement[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); + }; + }); + + // Support: Safari<7-8+, Chrome<37-44+ + // Add the top/left cssHooks using jQuery.fn.position + // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084 + // getComputedStyle returns percent when specified for + // top/left/bottom/right + // rather than make the css module depend on the offset + // module, we just check for it here + jQuery.each([ "top", "left" ], function(i, prop) { + jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function(elem, computed) { + if (computed) { + computed = curCSS(elem, prop); + + // if curCSS returns + // percentage, fallback + // to offset + return rnumnonpx.test(computed) ? jQuery(elem).position()[prop] + "px" : computed; + } + }); + }); + + // Create innerHeight, innerWidth, height, width, + // outerHeight and outerWidth methods + jQuery.each({ + Height : "height", + Width : "width" + }, function(name, type) { + jQuery.each({ + padding : "inner" + name, + content : type, + "" : "outer" + name + }, + function(defaultExtra, funcName) { + + // margin is only + // for outerHeight, + // outerWidth + jQuery.fn[funcName] = function(margin, value) { + var chainable = arguments.length + && (defaultExtra || typeof margin !== "boolean"), extra = defaultExtra + || (margin === true || value === true ? "margin" : "border"); + + return access(this, function(elem, type, value) { + var doc; + + if (jQuery.isWindow(elem)) { + + // As + // of + // 5/8/2012 + // this + // will + // yield + // incorrect + // results + // for + // Mobile + // Safari, + // but + // there + // isn't + // a + // whole + // lot + // we + // can + // do. + // See + // pull + // request + // at + // this + // URL + // for + // discussion: + // https://github.com/jquery/jquery/pull/764 + return elem.document.documentElement["client" + name]; + } + + // Get + // document + // width + // or + // height + if (elem.nodeType === 9) { + doc = elem.documentElement; + + // Either + // scroll[Width/Height] + // or + // offset[Width/Height] + // or + // client[Width/Height], + // whichever + // is + // greatest + // unfortunately, + // this + // causes + // bug + // #3838 + // in + // IE6/8 + // only, + // but + // there + // is + // currently + // no + // good, + // small + // way + // to + // fix + // it. + return Math.max(elem.body["scroll" + name], doc["scroll" + name], + elem.body["offset" + name], doc["offset" + name], doc["client" + + name]); + } + + return value === undefined ? + + // Get + // width + // or + // height + // on + // the + // element, + // requesting + // but + // not + // forcing + // parseFloat + jQuery.css(elem, type, extra) : + + // Set + // width + // or + // height + // on + // the + // element + jQuery.style(elem, type, value, extra); + }, type, chainable ? margin : undefined, chainable, null); + }; + }); + }); + + jQuery.fn.extend({ + + bind : function(types, data, fn) { + return this.on(types, null, data, fn); + }, + unbind : function(types, fn) { + return this.off(types, null, fn); + }, + + 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); + } + }); + + // The number of elements contained in the matched element + // set + jQuery.fn.size = function() { + return this.length; + }; + + jQuery.fn.andSelf = jQuery.fn.addBack; + + // Register as a named AMD module, since jQuery can be + // concatenated with other + // files that may use define, but not via 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. + + // Note that for maximum portability, libraries that are not + // jQuery should + // declare themselves as anonymous modules, and avoid + // setting a global if an + // AMD loader is present. jQuery is a special case. For more + // information, see + // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon + + if (typeof define === "function" && define.amd) { + define("jquery", [], function() { + return jQuery; + }); + } + + var + + // Map over jQuery in case of overwrite + _jQuery = window.jQuery, + + // Map over the $ in case of overwrite + _$ = window.$; + + jQuery.noConflict = function(deep) { + if (window.$ === jQuery) { + window.$ = _$; + } + + if (deep && window.jQuery === jQuery) { + window.jQuery = _jQuery; + } + + return jQuery; + }; + + // Expose jQuery and $ identifiers, even in + // AMD (#7102#comment:10, + // https://github.com/jquery/jquery/pull/557) + // and CommonJS for browser emulators (#13566) + if (!noGlobal) { + window.jQuery = window.$ = jQuery; + } + + return jQuery; + })); |