stratos-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From saj...@apache.org
Subject [06/13] stratos git commit: Add tenant based metering info to metering dashboard - STRATOS-1654 This closes #503
Date Tue, 09 Feb 2016 12:32:19 GMT
http://git-wip-us.apache.org/repos/asf/stratos/blob/c795440d/extensions/das/modules/artifacts/metering-dashboard/capps/stratos-metering-service/GadgetApplicationSignUps/Application_Signups/js/jquery.js
----------------------------------------------------------------------
diff --git a/extensions/das/modules/artifacts/metering-dashboard/capps/stratos-metering-service/GadgetApplicationSignUps/Application_Signups/js/jquery.js b/extensions/das/modules/artifacts/metering-dashboard/capps/stratos-metering-service/GadgetApplicationSignUps/Application_Signups/js/jquery.js
new file mode 100644
index 0000000..03c2242
--- /dev/null
+++ b/extensions/das/modules/artifacts/metering-dashboard/capps/stratos-metering-service/GadgetApplicationSignUps/Application_Signups/js/jquery.js
@@ -0,0 +1,9496 @@
+/*!
+ * jQuery JavaScript Library v1.8.3
+ * http://jquery.com/
+ *
+ * Includes Sizzle.js
+ * http://sizzlejs.com/
+ *
+ * Copyright 2012 jQuery Foundation and other contributors
+ * Released under the MIT license
+ * http://jquery.org/license
+ *
+ * Date: Tue Nov 13 2012 08:20:33 GMT-0500 (Eastern Standard Time)
+ */
+(function (window, undefined) {
+    var
+    // A central reference to the root jQuery(document)
+        rootjQuery,
+
+    // The deferred used on DOM ready
+        readyList,
+
+    // Use the correct document accordingly with window argument (sandbox)
+        document = window.document,
+        location = window.location,
+        navigator = window.navigator,
+
+    // Map over jQuery in case of overwrite
+        _jQuery = window.jQuery,
+
+    // Map over the $ in case of overwrite
+        _$ = window.$,
+
+    // Save a reference to some core methods
+        core_push = Array.prototype.push,
+        core_slice = Array.prototype.slice,
+        core_indexOf = Array.prototype.indexOf,
+        core_toString = Object.prototype.toString,
+        core_hasOwn = Object.prototype.hasOwnProperty,
+        core_trim = String.prototype.trim,
+
+    // Define a local copy of jQuery
+        jQuery = function (selector, context) {
+            // The jQuery object is actually just the init constructor 'enhanced'
+            return new jQuery.fn.init(selector, context, rootjQuery);
+        },
+
+    // Used for matching numbers
+        core_pnum = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source,
+
+    // Used for detecting and trimming whitespace
+        core_rnotwhite = /\S/,
+        core_rspace = /\s+/,
+
+    // Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
+        rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
+
+    // A simple way to check for HTML strings
+    // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
+        rquickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
+
+    // Match a standalone tag
+        rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
+
+    // JSON RegExp
+        rvalidchars = /^[\],:{}\s]*$/,
+        rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
+        rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
+        rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/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();
+        },
+
+    // The ready event handler and self cleanup method
+        DOMContentLoaded = function () {
+            if (document.addEventListener) {
+                document.removeEventListener("DOMContentLoaded", DOMContentLoaded, false);
+                jQuery.ready();
+            } else if (document.readyState === "complete") {
+                // we're here because readyState === "complete" in oldIE
+                // which is good enough for us to call the dom ready!
+                document.detachEvent("onreadystatechange", DOMContentLoaded);
+                jQuery.ready();
+            }
+        },
+
+    // [[Class]] -> type pairs
+        class2type = {};
+
+    jQuery.fn = jQuery.prototype = {
+        constructor: jQuery,
+        init: function (selector, context, rootjQuery) {
+            var match, elem, ret, doc;
+
+            // Handle $(""), $(null), $(undefined), $(false)
+            if (!selector) {
+                return this;
+            }
+
+            // Handle $(DOMElement)
+            if (selector.nodeType) {
+                this.context = this[0] = selector;
+                this.length = 1;
+                return this;
+            }
+
+            // 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;
+                        doc = ( context && context.nodeType ? context.ownerDocument || context : document );
+
+                        // scripts is true for back-compat
+                        selector = jQuery.parseHTML(match[1], doc, true);
+                        if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
+                            this.attr.call(selector, context, true);
+                        }
+
+                        return jQuery.merge(this, selector);
+
+                        // HANDLE: $(#id)
+                    } else {
+                        elem = document.getElementById(match[2]);
+
+                        // Check parentNode to catch when Blackberry 4.6 returns
+                        // nodes that are no longer in the document #6963
+                        if (elem && elem.parentNode) {
+                            // Handle the case where IE and Opera return items
+                            // by name instead of ID
+                            if (elem.id !== match[2]) {
+                                return rootjQuery.find(selector);
+                            }
+
+                            // Otherwise, we inject the element directly into the jQuery object
+                            this.length = 1;
+                            this[0] = elem;
+                        }
+
+                        this.context = document;
+                        this.selector = selector;
+                        return this;
+                    }
+
+                    // HANDLE: $(expr, $(...))
+                } else if (!context || context.jquery) {
+                    return ( context || rootjQuery ).find(selector);
+
+                    // HANDLE: $(expr, context)
+                    // (which is just equivalent to: $(context).find(expr)
+                } else {
+                    return this.constructor(context).find(selector);
+                }
+
+                // HANDLE: $(function)
+                // Shortcut for document ready
+            } else if (jQuery.isFunction(selector)) {
+                return rootjQuery.ready(selector);
+            }
+
+            if (selector.selector !== undefined) {
+                this.selector = selector.selector;
+                this.context = selector.context;
+            }
+
+            return jQuery.makeArray(selector, this);
+        },
+
+        // Start with an empty selector
+        selector: "",
+
+        // The current version of jQuery being used
+        jquery: "1.8.3",
+
+        // The default length of a jQuery object is 0
+        length: 0,
+
+        // The number of elements contained in the matched element set
+        size: function () {
+            return this.length;
+        },
+
+        toArray: function () {
+            return core_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 a 'clean' array
+                this.toArray() :
+
+                // Return just the object
+                ( num < 0 ? this[this.length + num] : this[num] );
+        },
+
+        // Take an array of elements and push it onto the stack
+        // (returning the new matched element set)
+        pushStack: function (elems, name, selector) {
+
+            // Build a new jQuery matched element set
+            var ret = jQuery.merge(this.constructor(), elems);
+
+            // Add the old object onto the stack (as a reference)
+            ret.prevObject = this;
+
+            ret.context = this.context;
+
+            if (name === "find") {
+                ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
+            } else if (name) {
+                ret.selector = this.selector + "." + name + "(" + selector + ")";
+            }
+
+            // Return the newly-formed element set
+            return ret;
+        },
+
+        // Execute a callback for every element in the matched set.
+        // (You can seed the arguments with an array of args, but this is
+        // only used internally.)
+        each: function (callback, args) {
+            return jQuery.each(this, callback, args);
+        },
+
+        ready: function (fn) {
+            // Add the callback
+            jQuery.ready.promise().done(fn);
+
+            return this;
+        },
+
+        eq: function (i) {
+            i = +i;
+            return i === -1 ?
+                this.slice(i) :
+                this.slice(i, i + 1);
+        },
+
+        first: function () {
+            return this.eq(0);
+        },
+
+        last: function () {
+            return this.eq(-1);
+        },
+
+        slice: function () {
+            return this.pushStack(core_slice.apply(this, arguments),
+                "slice", core_slice.call(arguments).join(","));
+        },
+
+        map: function (callback) {
+            return this.pushStack(jQuery.map(this, function (elem, i) {
+                return callback.call(elem, i, elem);
+            }));
+        },
+
+        end: function () {
+            return this.prevObject || this.constructor(null);
+        },
+
+        // For internal use only.
+        // Behaves like an Array's method, not like a jQuery method.
+        push: core_push,
+        sort: [].sort,
+        splice: [].splice
+    };
+
+// Give the init function the jQuery prototype for later instantiation
+    jQuery.fn.init.prototype = jQuery.fn;
+
+    jQuery.extend = jQuery.fn.extend = function () {
+        var options, name, src, copy, copyIsArray, clone,
+            target = arguments[0] || {},
+            i = 1,
+            length = arguments.length,
+            deep = false;
+
+        // Handle a deep copy situation
+        if (typeof target === "boolean") {
+            deep = target;
+            target = arguments[1] || {};
+            // skip the boolean and the target
+            i = 2;
+        }
+
+        // Handle case when target is a string or something (possible in deep copy)
+        if (typeof target !== "object" && !jQuery.isFunction(target)) {
+            target = {};
+        }
+
+        // extend jQuery itself if only one argument is passed
+        if (length === i) {
+            target = this;
+            --i;
+        }
+
+        for (; i < length; i++) {
+            // Only deal with non-null/undefined values
+            if ((options = arguments[i]) != null) {
+                // Extend the base object
+                for (name in options) {
+                    src = target[name];
+                    copy = options[name];
+
+                    // Prevent never-ending loop
+                    if (target === copy) {
+                        continue;
+                    }
+
+                    // Recurse if we're merging plain objects or arrays
+                    if (deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) )) {
+                        if (copyIsArray) {
+                            copyIsArray = false;
+                            clone = src && jQuery.isArray(src) ? src : [];
+
+                        } else {
+                            clone = src && jQuery.isPlainObject(src) ? src : {};
+                        }
+
+                        // Never move original objects, clone them
+                        target[name] = jQuery.extend(deep, clone, copy);
+
+                        // Don't bring in undefined values
+                    } else if (copy !== undefined) {
+                        target[name] = copy;
+                    }
+                }
+            }
+        }
+
+        // Return the modified object
+        return target;
+    };
+
+    jQuery.extend({
+        noConflict: function (deep) {
+            if (window.$ === jQuery) {
+                window.$ = _$;
+            }
+
+            if (deep && window.jQuery === jQuery) {
+                window.jQuery = _jQuery;
+            }
+
+            return jQuery;
+        },
+
+        // Is the DOM ready to be used? Set to true once it occurs.
+        isReady: false,
+
+        // A counter to track how many items to wait for before
+        // the ready event fires. See #6781
+        readyWait: 1,
+
+        // Hold (or release) the ready event
+        holdReady: function (hold) {
+            if (hold) {
+                jQuery.readyWait++;
+            } else {
+                jQuery.ready(true);
+            }
+        },
+
+        // Handle when the DOM is ready
+        ready: function (wait) {
+
+            // Abort if there are pending holds or we're already ready
+            if (wait === true ? --jQuery.readyWait : jQuery.isReady) {
+                return;
+            }
+
+            // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+            if (!document.body) {
+                return setTimeout(jQuery.ready, 1);
+            }
+
+            // Remember that the DOM is ready
+            jQuery.isReady = true;
+
+            // If a normal DOM Ready event fired, decrement, and wait if need be
+            if (wait !== true && --jQuery.readyWait > 0) {
+                return;
+            }
+
+            // If there are functions bound, to execute
+            readyList.resolveWith(document, [jQuery]);
+
+            // Trigger any bound ready events
+            if (jQuery.fn.trigger) {
+                jQuery(document).trigger("ready").off("ready");
+            }
+        },
+
+        // See test/unit/core.js for details concerning isFunction.
+        // Since version 1.3, DOM methods and functions like alert
+        // aren't supported. They return false on IE (#2968).
+        isFunction: function (obj) {
+            return jQuery.type(obj) === "function";
+        },
+
+        isArray: Array.isArray || function (obj) {
+            return jQuery.type(obj) === "array";
+        },
+
+        isWindow: function (obj) {
+            return obj != null && obj == obj.window;
+        },
+
+        isNumeric: function (obj) {
+            return !isNaN(parseFloat(obj)) && isFinite(obj);
+        },
+
+        type: function (obj) {
+            return obj == null ?
+                String(obj) :
+            class2type[core_toString.call(obj)] || "object";
+        },
+
+        isPlainObject: function (obj) {
+            // Must be an Object.
+            // Because of IE, we also have to check the presence of the constructor property.
+            // Make sure that DOM nodes and window objects don't pass through, as well
+            if (!obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow(obj)) {
+                return false;
+            }
+
+            try {
+                // Not own constructor property must be Object
+                if (obj.constructor && !core_hasOwn.call(obj, "constructor") && !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
+                    return false;
+                }
+            } catch (e) {
+                // IE8,9 Will throw exceptions on certain host objects #9897
+                return false;
+            }
+
+            // Own properties are enumerated firstly, so to speed up,
+            // if last one is own, then all properties are own.
+
+            var key;
+            for (key in obj) {
+            }
+
+            return key === undefined || core_hasOwn.call(obj, key);
+        },
+
+        isEmptyObject: function (obj) {
+            var name;
+            for (name in obj) {
+                return false;
+            }
+            return true;
+        },
+
+        error: function (msg) {
+            throw new Error(msg);
+        },
+
+        // data: string of html
+        // context (optional): If specified, the fragment will be created in this context, defaults to document
+        // scripts (optional): If true, will include scripts passed in the html string
+        parseHTML: function (data, context, scripts) {
+            var parsed;
+            if (!data || typeof data !== "string") {
+                return null;
+            }
+            if (typeof context === "boolean") {
+                scripts = context;
+                context = 0;
+            }
+            context = context || document;
+
+            // Single tag
+            if ((parsed = rsingleTag.exec(data))) {
+                return [context.createElement(parsed[1])];
+            }
+
+            parsed = jQuery.buildFragment([data], context, scripts ? null : []);
+            return jQuery.merge([],
+                (parsed.cacheable ? jQuery.clone(parsed.fragment) : parsed.fragment).childNodes);
+        },
+
+        parseJSON: function (data) {
+            if (!data || typeof data !== "string") {
+                return null;
+            }
+
+            // Make sure leading/trailing whitespace is removed (IE can't handle it)
+            data = jQuery.trim(data);
+
+            // Attempt to parse using the native JSON parser first
+            if (window.JSON && window.JSON.parse) {
+                return window.JSON.parse(data);
+            }
+
+            // Make sure the incoming data is actual JSON
+            // Logic borrowed from http://json.org/json2.js
+            if (rvalidchars.test(data.replace(rvalidescape, "@")
+                    .replace(rvalidtokens, "]")
+                    .replace(rvalidbraces, ""))) {
+
+                return ( new Function("return " + data) )();
+
+            }
+            jQuery.error("Invalid JSON: " + data);
+        },
+
+        // Cross-browser xml parsing
+        parseXML: function (data) {
+            var xml, tmp;
+            if (!data || typeof data !== "string") {
+                return null;
+            }
+            try {
+                if (window.DOMParser) { // Standard
+                    tmp = new DOMParser();
+                    xml = tmp.parseFromString(data, "text/xml");
+                } else { // IE
+                    xml = new ActiveXObject("Microsoft.XMLDOM");
+                    xml.async = "false";
+                    xml.loadXML(data);
+                }
+            } catch (e) {
+                xml = undefined;
+            }
+            if (!xml || !xml.documentElement || xml.getElementsByTagName("parsererror").length) {
+                jQuery.error("Invalid XML: " + data);
+            }
+            return xml;
+        },
+
+        noop: function () {
+        },
+
+        // Evaluates a script in a global context
+        // Workarounds based on findings by Jim Driscoll
+        // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
+        globalEval: function (data) {
+            if (data && core_rnotwhite.test(data)) {
+                // We use execScript on Internet Explorer
+                // We use an anonymous function so that context is window
+                // rather than jQuery in Firefox
+                ( window.execScript || function (data) {
+                    window["eval"].call(window, data);
+                } )(data);
+            }
+        },
+
+        // Convert dashed to camelCase; used by the css and data modules
+        // Microsoft forgot to hump their vendor prefix (#9572)
+        camelCase: function (string) {
+            return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
+        },
+
+        nodeName: function (elem, name) {
+            return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
+        },
+
+        // args is for internal usage only
+        each: function (obj, callback, args) {
+            var name,
+                i = 0,
+                length = obj.length,
+                isObj = length === undefined || jQuery.isFunction(obj);
+
+            if (args) {
+                if (isObj) {
+                    for (name in obj) {
+                        if (callback.apply(obj[name], args) === false) {
+                            break;
+                        }
+                    }
+                } else {
+                    for (; i < length;) {
+                        if (callback.apply(obj[i++], args) === false) {
+                            break;
+                        }
+                    }
+                }
+
+                // A special, fast, case for the most common use of each
+            } else {
+                if (isObj) {
+                    for (name in obj) {
+                        if (callback.call(obj[name], name, obj[name]) === false) {
+                            break;
+                        }
+                    }
+                } else {
+                    for (; i < length;) {
+                        if (callback.call(obj[i], i, obj[i++]) === false) {
+                            break;
+                        }
+                    }
+                }
+            }
+
+            return obj;
+        },
+
+        // Use native String.trim function wherever possible
+        trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
+            function (text) {
+                return text == null ?
+                    "" :
+                    core_trim.call(text);
+            } :
+
+            // Otherwise use our own trimming functionality
+            function (text) {
+                return text == null ?
+                    "" :
+                    ( text + "" ).replace(rtrim, "");
+            },
+
+        // results is for internal usage only
+        makeArray: function (arr, results) {
+            var type,
+                ret = results || [];
+
+            if (arr != null) {
+                // The window, strings (and functions) also have 'length'
+                // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
+                type = jQuery.type(arr);
+
+                if (arr.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow(arr)) {
+                    core_push.call(ret, arr);
+                } else {
+                    jQuery.merge(ret, arr);
+                }
+            }
+
+            return ret;
+        },
+
+        inArray: function (elem, arr, i) {
+            var len;
+
+            if (arr) {
+                if (core_indexOf) {
+                    return core_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 l = second.length,
+                i = first.length,
+                j = 0;
+
+            if (typeof l === "number") {
+                for (; j < l; j++) {
+                    first[i++] = second[j];
+                }
+
+            } else {
+                while (second[j] !== undefined) {
+                    first[i++] = second[j++];
+                }
+            }
+
+            first.length = i;
+
+            return first;
+        },
+
+        grep: function (elems, callback, inv) {
+            var retVal,
+                ret = [],
+                i = 0,
+                length = elems.length;
+            inv = !!inv;
+
+            // Go through the array, only saving the items
+            // that pass the validator function
+            for (; i < length; i++) {
+                retVal = !!callback(elems[i], i);
+                if (inv !== retVal) {
+                    ret.push(elems[i]);
+                }
+            }
+
+            return ret;
+        },
+
+        // arg is for internal usage only
+        map: function (elems, callback, arg) {
+            var value, key,
+                ret = [],
+                i = 0,
+                length = elems.length,
+            // jquery objects are treated as arrays
+                isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[0] && elems[length - 1] ) || length === 0 || jQuery.isArray(elems) );
+
+            // Go through the array, translating each of the items to their
+            if (isArray) {
+                for (; i < length; i++) {
+                    value = callback(elems[i], i, arg);
+
+                    if (value != null) {
+                        ret[ret.length] = value;
+                    }
+                }
+
+                // Go through every key on the object,
+            } else {
+                for (key in elems) {
+                    value = callback(elems[key], key, arg);
+
+                    if (value != null) {
+                        ret[ret.length] = value;
+                    }
+                }
+            }
+
+            // Flatten any nested arrays
+            return ret.concat.apply([], ret);
+        },
+
+        // A global GUID counter for objects
+        guid: 1,
+
+        // Bind a function to a context, optionally partially applying any
+        // arguments.
+        proxy: function (fn, context) {
+            var tmp, args, proxy;
+
+            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 = core_slice.call(arguments, 2);
+            proxy = function () {
+                return fn.apply(context, args.concat(core_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;
+        },
+
+        // Multifunctional method to get and set values of a collection
+        // The value/s can optionally be executed if it's a function
+        access: function (elems, fn, key, value, chainable, emptyGet, pass) {
+            var exec,
+                bulk = key == null,
+                i = 0,
+                length = elems.length;
+
+            // Sets many values
+            if (key && typeof key === "object") {
+                for (i in key) {
+                    jQuery.access(elems, fn, i, key[i], 1, emptyGet, value);
+                }
+                chainable = 1;
+
+                // Sets one value
+            } else if (value !== undefined) {
+                // Optionally, function values get executed if exec is true
+                exec = pass === undefined && jQuery.isFunction(value);
+
+                if (bulk) {
+                    // Bulk operations only iterate when executing function values
+                    if (exec) {
+                        exec = fn;
+                        fn = function (elem, key, value) {
+                            return exec.call(jQuery(elem), value);
+                        };
+
+                        // Otherwise they run against the entire set
+                    } else {
+                        fn.call(elems, value);
+                        fn = null;
+                    }
+                }
+
+                if (fn) {
+                    for (; i < length; i++) {
+                        fn(elems[i], key, exec ? value.call(elems[i], i, fn(elems[i], key)) : value, pass);
+                    }
+                }
+
+                chainable = 1;
+            }
+
+            return chainable ?
+                elems :
+
+                // Gets
+                bulk ?
+                    fn.call(elems) :
+                    length ? fn(elems[0], key) : emptyGet;
+        },
+
+        now: function () {
+            return ( new Date() ).getTime();
+        }
+    });
+
+    jQuery.ready.promise = function (obj) {
+        if (!readyList) {
+
+            readyList = jQuery.Deferred();
+
+            // Catch cases where $(document).ready() is called after the browser event has already occurred.
+            // we once tried to use readyState "interactive" here, but it caused issues like the one
+            // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
+            if (document.readyState === "complete") {
+                // Handle it asynchronously to allow scripts the opportunity to delay ready
+                setTimeout(jQuery.ready, 1);
+
+                // Standards-based browsers support DOMContentLoaded
+            } else if (document.addEventListener) {
+                // Use the handy event callback
+                document.addEventListener("DOMContentLoaded", DOMContentLoaded, false);
+
+                // A fallback to window.onload, that will always work
+                window.addEventListener("load", jQuery.ready, false);
+
+                // If IE event model is used
+            } else {
+                // Ensure firing before onload, maybe late but safe also for iframes
+                document.attachEvent("onreadystatechange", DOMContentLoaded);
+
+                // A fallback to window.onload, that will always work
+                window.attachEvent("onload", jQuery.ready);
+
+                // If IE and not a frame
+                // continually check to see if the document is ready
+                var 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 setTimeout(doScrollCheck, 50);
+                            }
+
+                            // and execute any waiting functions
+                            jQuery.ready();
+                        }
+                    })();
+                }
+            }
+        }
+        return readyList.promise(obj);
+    };
+
+// Populate the class2type map
+    jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function (i, name) {
+        class2type["[object " + name + "]"] = name.toLowerCase();
+    });
+
+// All jQuery objects should point back to these
+    rootjQuery = jQuery(document);
+// String to Object options format cache
+    var optionsCache = {};
+
+// Convert String-formatted options into Object-formatted ones and store in cache
+    function createOptions(options) {
+        var object = optionsCache[options] = {};
+        jQuery.each(options.split(core_rspace), 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" ?
+            ( optionsCache[options] || createOptions(options) ) :
+            jQuery.extend({}, options);
+
+        var // Last fire value (for non-forgettable lists)
+            memory,
+        // Flag to know if list was already fired
+            fired,
+        // Flag to know if list is currently firing
+            firing,
+        // First callback to fire (used internally by add and fireWith)
+            firingStart,
+        // End of the loop when firing
+            firingLength,
+        // Index of currently firing callback (modified by remove if needed)
+            firingIndex,
+        // Actual callback list
+            list = [],
+        // Stack of fire calls for repeatable lists
+            stack = !options.once && [],
+        // Fire callbacks
+            fire = function (data) {
+                memory = options.memory && data;
+                fired = true;
+                firingIndex = firingStart || 0;
+                firingStart = 0;
+                firingLength = list.length;
+                firing = true;
+                for (; list && firingIndex < firingLength; firingIndex++) {
+                    if (list[firingIndex].apply(data[0], data[1]) === false && options.stopOnFalse) {
+                        memory = false; // To prevent further calls using add
+                        break;
+                    }
+                }
+                firing = false;
+                if (list) {
+                    if (stack) {
+                        if (stack.length) {
+                            fire(stack.shift());
+                        }
+                    } else if (memory) {
+                        list = [];
+                    } else {
+                        self.disable();
+                    }
+                }
+            },
+        // Actual Callbacks object
+            self = {
+                // Add a callback or a collection of callbacks to the list
+                add: function () {
+                    if (list) {
+                        // First, we save the current length
+                        var start = list.length;
+                        (function add(args) {
+                            jQuery.each(args, function (_, arg) {
+                                var type = jQuery.type(arg);
+                                if (type === "function") {
+                                    if (!options.unique || !self.has(arg)) {
+                                        list.push(arg);
+                                    }
+                                } else if (arg && arg.length && type !== "string") {
+                                    // Inspect recursively
+                                    add(arg);
+                                }
+                            });
+                        })(arguments);
+                        // Do we need to add the callbacks to the
+                        // current firing batch?
+                        if (firing) {
+                            firingLength = list.length;
+                            // With memory, if we're not firing then
+                            // we should call right away
+                        } else if (memory) {
+                            firingStart = start;
+                            fire(memory);
+                        }
+                    }
+                    return this;
+                },
+                // Remove a callback from the list
+                remove: function () {
+                    if (list) {
+                        jQuery.each(arguments, function (_, arg) {
+                            var index;
+                            while (( index = jQuery.inArray(arg, list, index) ) > -1) {
+                                list.splice(index, 1);
+                                // Handle firing indexes
+                                if (firing) {
+                                    if (index <= firingLength) {
+                                        firingLength--;
+                                    }
+                                    if (index <= firingIndex) {
+                                        firingIndex--;
+                                    }
+                                }
+                            }
+                        });
+                    }
+                    return this;
+                },
+                // Control if a given callback is in the list
+                has: function (fn) {
+                    return jQuery.inArray(fn, list) > -1;
+                },
+                // Remove all callbacks from the list
+                empty: function () {
+                    list = [];
+                    return this;
+                },
+                // Have the list do nothing anymore
+                disable: function () {
+                    list = stack = memory = undefined;
+                    return this;
+                },
+                // Is it disabled?
+                disabled: function () {
+                    return !list;
+                },
+                // Lock the list in its current state
+                lock: function () {
+                    stack = undefined;
+                    if (!memory) {
+                        self.disable();
+                    }
+                    return this;
+                },
+                // Is it locked?
+                locked: function () {
+                    return !stack;
+                },
+                // Call all callbacks with the given context and arguments
+                fireWith: function (context, args) {
+                    args = args || [];
+                    args = [context, args.slice ? args.slice() : args];
+                    if (list && ( !fired || stack )) {
+                        if (firing) {
+                            stack.push(args);
+                        } else {
+                            fire(args);
+                        }
+                    }
+                    return this;
+                },
+                // Call all the callbacks with the given arguments
+                fire: function () {
+                    self.fireWith(this, arguments);
+                    return this;
+                },
+                // To know if the callbacks have already been called at least once
+                fired: function () {
+                    return !!fired;
+                }
+            };
+
+        return self;
+    };
+    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 action = tuple[0],
+                                    fn = fns[i];
+                                // deferred[ done | fail | progress ] for forwarding actions to newDefer
+                                deferred[tuple[1]](jQuery.isFunction(fn) ?
+                                    function () {
+                                        var returned = fn.apply(this, arguments);
+                                        if (returned && jQuery.isFunction(returned.promise)) {
+                                            returned.promise()
+                                                .done(newDefer.resolve)
+                                                .fail(newDefer.reject)
+                                                .progress(newDefer.notify);
+                                        } else {
+                                            newDefer[action + "With"](this === deferred ? newDefer : this, [returned]);
+                                        }
+                                    } :
+                                    newDefer[action]
+                                );
+                            });
+                            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 ] = list.fire
+                deferred[tuple[0]] = list.fire;
+                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 = core_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 ? core_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()
+                            .done(updateFunc(i, resolveContexts, resolveValues))
+                            .fail(deferred.reject)
+                            .progress(updateFunc(i, progressContexts, progressValues));
+                    } else {
+                        --remaining;
+                    }
+                }
+            }
+
+            // if we're not waiting on anything, resolve the master
+            if (!remaining) {
+                deferred.resolveWith(resolveContexts, resolveValues);
+            }
+
+            return deferred.promise();
+        }
+    });
+    jQuery.support = (function () {
+
+        var support,
+            all,
+            a,
+            select,
+            opt,
+            input,
+            fragment,
+            eventName,
+            i,
+            isSupported,
+            clickFn,
+            div = document.createElement("div");
+
+        // Setup
+        div.setAttribute("className", "t");
+        div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
+
+        // Support tests won't run in some limited or non-browser environments
+        all = div.getElementsByTagName("*");
+        a = div.getElementsByTagName("a")[0];
+        if (!all || !a || !all.length) {
+            return {};
+        }
+
+        // First batch of tests
+        select = document.createElement("select");
+        opt = select.appendChild(document.createElement("option"));
+        input = div.getElementsByTagName("input")[0];
+
+        a.style.cssText = "top:1px;float:left;opacity:.5";
+        support = {
+            // IE strips leading whitespace when .innerHTML is used
+            leadingWhitespace: ( div.firstChild.nodeType === 3 ),
+
+            // Make sure that tbody elements aren't automatically inserted
+            // IE will insert them into empty tables
+            tbody: !div.getElementsByTagName("tbody").length,
+
+            // Make sure that link elements get serialized correctly by innerHTML
+            // This requires a wrapper element in IE
+            htmlSerialize: !!div.getElementsByTagName("link").length,
+
+            // Get the style information from getAttribute
+            // (IE uses .cssText instead)
+            style: /top/.test(a.getAttribute("style")),
+
+            // Make sure that URLs aren't manipulated
+            // (IE normalizes it by default)
+            hrefNormalized: ( a.getAttribute("href") === "/a" ),
+
+            // Make sure that element opacity exists
+            // (IE uses filter instead)
+            // Use a regex to work around a WebKit issue. See #5145
+            opacity: /^0.5/.test(a.style.opacity),
+
+            // Verify style float existence
+            // (IE uses styleFloat instead of cssFloat)
+            cssFloat: !!a.style.cssFloat,
+
+            // Make sure that if no value is specified for a checkbox
+            // that it defaults to "on".
+            // (WebKit defaults to "" instead)
+            checkOn: ( input.value === "on" ),
+
+            // Make sure that a selected-by-default option has a working selected property.
+            // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
+            optSelected: opt.selected,
+
+            // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
+            getSetAttribute: div.className !== "t",
+
+            // Tests for enctype support on a form (#6743)
+            enctype: !!document.createElement("form").enctype,
+
+            // Makes sure cloning an html5 element does not cause problems
+            // Where outerHTML is undefined, this still works
+            html5Clone: document.createElement("nav").cloneNode(true).outerHTML !== "<:nav></:nav>",
+
+            // jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
+            boxModel: ( document.compatMode === "CSS1Compat" ),
+
+            // Will be defined later
+            submitBubbles: true,
+            changeBubbles: true,
+            focusinBubbles: false,
+            deleteExpando: true,
+            noCloneEvent: true,
+            inlineBlockNeedsLayout: false,
+            shrinkWrapBlocks: false,
+            reliableMarginRight: true,
+            boxSizingReliable: true,
+            pixelPosition: false
+        };
+
+        // Make sure checked status is properly cloned
+        input.checked = true;
+        support.noCloneChecked = input.cloneNode(true).checked;
+
+        // Make sure that the options inside disabled selects aren't marked as disabled
+        // (WebKit marks them as disabled)
+        select.disabled = true;
+        support.optDisabled = !opt.disabled;
+
+        // Test to see if it's possible to delete an expando from an element
+        // Fails in Internet Explorer
+        try {
+            delete div.test;
+        } catch (e) {
+            support.deleteExpando = false;
+        }
+
+        if (!div.addEventListener && div.attachEvent && div.fireEvent) {
+            div.attachEvent("onclick", clickFn = function () {
+                // Cloning a node shouldn't copy over any
+                // bound event handlers (IE does this)
+                support.noCloneEvent = false;
+            });
+            div.cloneNode(true).fireEvent("onclick");
+            div.detachEvent("onclick", clickFn);
+        }
+
+        // Check if a radio maintains its value
+        // after being appended to the DOM
+        input = document.createElement("input");
+        input.value = "t";
+        input.setAttribute("type", "radio");
+        support.radioValue = input.value === "t";
+
+        input.setAttribute("checked", "checked");
+
+        // #11217 - WebKit loses check when the name is after the checked attribute
+        input.setAttribute("name", "t");
+
+        div.appendChild(input);
+        fragment = document.createDocumentFragment();
+        fragment.appendChild(div.lastChild);
+
+        // WebKit doesn't clone checked state correctly in fragments
+        support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
+
+        // Check if a disconnected checkbox will retain its checked
+        // value of true after appended to the DOM (IE6/7)
+        support.appendChecked = input.checked;
+
+        fragment.removeChild(input);
+        fragment.appendChild(div);
+
+        // Technique from Juriy Zaytsev
+        // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
+        // We only care about the case where non-standard event systems
+        // are used, namely in IE. Short-circuiting here helps us to
+        // avoid an eval call (in setAttribute) which can cause CSP
+        // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
+        if (div.attachEvent) {
+            for (i in {
+                submit: true,
+                change: true,
+                focusin: true
+            }) {
+                eventName = "on" + i;
+                isSupported = ( eventName in div );
+                if (!isSupported) {
+                    div.setAttribute(eventName, "return;");
+                    isSupported = ( typeof div[eventName] === "function" );
+                }
+                support[i + "Bubbles"] = isSupported;
+            }
+        }
+
+        // Run tests that need a body at doc ready
+        jQuery(function () {
+            var container, div, tds, marginDiv,
+                divReset = "padding:0;margin:0;border:0;display:block;overflow:hidden;",
+                body = document.getElementsByTagName("body")[0];
+
+            if (!body) {
+                // Return for frameset docs that don't have a body
+                return;
+            }
+
+            container = document.createElement("div");
+            container.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px";
+            body.insertBefore(container, body.firstChild);
+
+            // Construct the test element
+            div = document.createElement("div");
+            container.appendChild(div);
+
+            // Check if table cells still have offsetWidth/Height when they are set
+            // to display:none and there are still other visible table cells in a
+            // table row; if so, offsetWidth/Height are not reliable for use when
+            // determining if an element has been hidden directly using
+            // display:none (it is still safe to use offsets if a parent element is
+            // hidden; don safety goggles and see bug #4512 for more information).
+            // (only IE 8 fails this test)
+            div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
+            tds = div.getElementsByTagName("td");
+            tds[0].style.cssText = "padding:0;margin:0;border:0;display:none";
+            isSupported = ( tds[0].offsetHeight === 0 );
+
+            tds[0].style.display = "";
+            tds[1].style.display = "none";
+
+            // Check if empty table cells still have offsetWidth/Height
+            // (IE <= 8 fail this test)
+            support.reliableHiddenOffsets = isSupported && ( tds[0].offsetHeight === 0 );
+
+            // Check box-sizing and margin behavior
+            div.innerHTML = "";
+            div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
+            support.boxSizing = ( div.offsetWidth === 4 );
+            support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
+
+            // NOTE: To any future maintainer, we've window.getComputedStyle
+            // because jsdom on node.js will break without it.
+            if (window.getComputedStyle) {
+                support.pixelPosition = ( window.getComputedStyle(div, null) || {} ).top !== "1%";
+                support.boxSizingReliable = ( window.getComputedStyle(div, null) || {width: "4px"} ).width === "4px";
+
+                // Check if div with explicit width and no margin-right incorrectly
+                // gets computed margin-right based on width of container. For more
+                // info see bug #3333
+                // Fails in WebKit before Feb 2011 nightlies
+                // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
+                marginDiv = document.createElement("div");
+                marginDiv.style.cssText = div.style.cssText = divReset;
+                marginDiv.style.marginRight = marginDiv.style.width = "0";
+                div.style.width = "1px";
+                div.appendChild(marginDiv);
+                support.reliableMarginRight = !parseFloat(( window.getComputedStyle(marginDiv, null) || {} ).marginRight);
+            }
+
+            if (typeof div.style.zoom !== "undefined") {
+                // Check if natively block-level elements act like inline-block
+                // elements when setting their display to 'inline' and giving
+                // them layout
+                // (IE < 8 does this)
+                div.innerHTML = "";
+                div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
+                support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
+
+                // Check if elements with layout shrink-wrap their children
+                // (IE 6 does this)
+                div.style.display = "block";
+                div.style.overflow = "visible";
+                div.innerHTML = "<div></div>";
+                div.firstChild.style.width = "5px";
+                support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
+
+                container.style.zoom = 1;
+            }
+
+            // Null elements to avoid leaks in IE
+            body.removeChild(container);
+            container = div = tds = marginDiv = null;
+        });
+
+        // Null elements to avoid leaks in IE
+        fragment.removeChild(div);
+        all = a = select = opt = input = fragment = div = null;
+
+        return support;
+    })();
+    var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
+        rmultiDash = /([A-Z])/g;
+
+    jQuery.extend({
+        cache: {},
+
+        deletedIds: [],
+
+        // Remove at next major release (1.9/2.0)
+        uuid: 0,
+
+        // Unique for each copy of jQuery on the page
+        // Non-digits removed to match rinlinejQuery
+        expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace(/\D/g, ""),
+
+        // The following elements throw uncatchable exceptions if you
+        // attempt to add expando properties to them.
+        noData: {
+            "embed": true,
+            // Ban all objects except for Flash (which handle expandos)
+            "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
+            "applet": true
+        },
+
+        hasData: function (elem) {
+            elem = elem.nodeType ? jQuery.cache[elem[jQuery.expando]] : elem[jQuery.expando];
+            return !!elem && !isEmptyDataObject(elem);
+        },
+
+        data: function (elem, name, data, pvt /* Internal Use Only */) {
+            if (!jQuery.acceptData(elem)) {
+                return;
+            }
+
+            var thisCache, ret,
+                internalKey = jQuery.expando,
+                getByName = typeof name === "string",
+
+            // We have to handle DOM nodes and JS objects differently because IE6-7
+            // can't GC object references properly across the DOM-JS boundary
+                isNode = elem.nodeType,
+
+            // Only DOM nodes need the global jQuery cache; JS object data is
+            // attached directly to the object so GC can occur automatically
+                cache = isNode ? jQuery.cache : elem,
+
+            // Only defining an ID for JS objects if its cache already exists allows
+            // the code to shortcut on the same path as a DOM node with no cache
+                id = isNode ? elem[internalKey] : elem[internalKey] && internalKey;
+
+            // 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)) && getByName && data === undefined) {
+                return;
+            }
+
+            if (!id) {
+                // Only DOM nodes need a new unique ID for each element since their data
+                // ends up in the global cache
+                if (isNode) {
+                    elem[internalKey] = id = jQuery.deletedIds.pop() || jQuery.guid++;
+                } else {
+                    id = internalKey;
+                }
+            }
+
+            if (!cache[id]) {
+                cache[id] = {};
+
+                // Avoids exposing jQuery metadata on plain JS objects when the object
+                // is serialized using JSON.stringify
+                if (!isNode) {
+                    cache[id].toJSON = jQuery.noop;
+                }
+            }
+
+            // An object can be passed to jQuery.data instead of a key/value pair; this gets
+            // shallow copied over onto the existing cache
+            if (typeof name === "object" || typeof name === "function") {
+                if (pvt) {
+                    cache[id] = jQuery.extend(cache[id], name);
+                } else {
+                    cache[id].data = jQuery.extend(cache[id].data, name);
+                }
+            }
+
+            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 (getByName) {
+
+                // First Try to find as-is property data
+                ret = thisCache[name];
+
+                // Test for null|undefined property data
+                if (ret == null) {
+
+                    // Try to find the camelCased property
+                    ret = thisCache[jQuery.camelCase(name)];
+                }
+            } else {
+                ret = thisCache;
+            }
+
+            return ret;
+        },
+
+        removeData: function (elem, name, pvt /* Internal Use Only */) {
+            if (!jQuery.acceptData(elem)) {
+                return;
+            }
+
+            var thisCache, i, l,
+
+                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(" ");
+                            }
+                        }
+                    }
+
+                    for (i = 0, l = name.length; i < l; i++) {
+                        delete thisCache[name[i]];
+                    }
+
+                    // If there is no data left in the cache, we want to continue
+                    // and let the cache object itself get destroyed
+                    if (!( pvt ? isEmptyDataObject : jQuery.isEmptyObject )(thisCache)) {
+                        return;
+                    }
+                }
+            }
+
+            // See jQuery.data for more information
+            if (!pvt) {
+                delete cache[id].data;
+
+                // Don't destroy the parent cache unless the internal data object
+                // had been the only thing left in it
+                if (!isEmptyDataObject(cache[id])) {
+                    return;
+                }
+            }
+
+            // Destroy the cache
+            if (isNode) {
+                jQuery.cleanData([elem], true);
+
+                // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
+            } else if (jQuery.support.deleteExpando || cache != cache.window) {
+                delete cache[id];
+
+                // When all else fails, null
+            } else {
+                cache[id] = null;
+            }
+        },
+
+        // For internal use only.
+        _data: function (elem, name, data) {
+            return jQuery.data(elem, name, data, true);
+        },
+
+        // A method for determining if a DOM node can handle the data expando
+        acceptData: function (elem) {
+            var noData = elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()];
+
+            // nodes accept data unless otherwise specified; rejection can be conditional
+            return !noData || noData !== true && elem.getAttribute("classid") === noData;
+        }
+    });
+
+    jQuery.fn.extend({
+        data: function (key, value) {
+            var parts, part, attr, name, l,
+                elem = this[0],
+                i = 0,
+                data = null;
+
+            // Gets all values
+            if (key === undefined) {
+                if (this.length) {
+                    data = jQuery.data(elem);
+
+                    if (elem.nodeType === 1 && !jQuery._data(elem, "parsedAttrs")) {
+                        attr = elem.attributes;
+                        for (l = attr.length; i < l; i++) {
+                            name = attr[i].name;
+
+                            if (!name.indexOf("data-")) {
+                                name = jQuery.camelCase(name.substring(5));
+
+                                dataAttr(elem, name, data[name]);
+                            }
+                        }
+                        jQuery._data(elem, "parsedAttrs", true);
+                    }
+                }
+
+                return data;
+            }
+
+            // Sets multiple values
+            if (typeof key === "object") {
+                return this.each(function () {
+                    jQuery.data(this, key);
+                });
+            }
+
+            parts = key.split(".", 2);
+            parts[1] = parts[1] ? "." + parts[1] : "";
+            part = parts[1] + "!";
+
+            return jQuery.access(this, function (value) {
+
+                if (value === undefined) {
+                    data = this.triggerHandler("getData" + part, [parts[0]]);
+
+                    // Try to fetch any internally stored data first
+                    if (data === undefined && elem) {
+                        data = jQuery.data(elem, key);
+                        data = dataAttr(elem, key, data);
+                    }
+
+                    return data === undefined && parts[1] ?
+                        this.data(parts[0]) :
+                        data;
+                }
+
+                parts[1] = value;
+                this.each(function () {
+                    var self = jQuery(this);
+
+                    self.triggerHandler("setData" + part, parts);
+                    jQuery.data(this, key, value);
+                    self.triggerHandler("changeData" + part, parts);
+                });
+            }, null, value, arguments.length > 1, null, false);
+        },
+
+        removeData: function (key) {
+            return this.each(function () {
+                jQuery.removeData(this, key);
+            });
+        }
+    });
+
+    function dataAttr(elem, key, data) {
+        // If nothing was found internally, try to fetch any
+        // data from the HTML5 data-* attribute
+        if (data === undefined && elem.nodeType === 1) {
+
+            var name = "data-" + key.replace(rmultiDash, "-$1").toLowerCase();
+
+            data = elem.getAttribute(name);
+
+            if (typeof data === "string") {
+                try {
+                    data = data === "true" ? true :
+                        data === "false" ? false :
+                            data === "null" ? null :
+                                // 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;
+    }
+
+    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", true);
+                        jQuery.removeData(elem, key, true);
+                    })
+                });
+        }
+    });
+
+    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);
+            });
+        },
+        // Based off of the plugin by Clint Helfers, with permission.
+        // http://blindsignals.com/index.php/2009/07/jquery-delay/
+        delay: function (time, type) {
+            time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
+            type = type || "fx";
+
+            return this.queue(type, function (next, hooks) {
+                var timeout = setTimeout(next, time);
+                hooks.stop = function () {
+                    clearTimeout(timeout);
+                };
+            });
+        },
+        clearQueue: function (type) {
+            return this.queue(type || "fx", []);
+        },
+        // Get a promise resolved when queues of a certain type
+        // are emptied (fx is the type by default)
+        promise: function (type, 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);
+        }
+    });
+    var nodeHook, boolHook, fixSpecified,
+        rclass = /[\t\r\n]/g,
+        rreturn = /\r/g,
+        rtype = /^(?:button|input)$/i,
+        rfocusable = /^(?:button|input|object|select|textarea)$/i,
+        rclickable = /^a(?:rea|)$/i,
+        rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
+        getSetAttribute = jQuery.support.getSetAttribute;
+
+    jQuery.fn.extend({
+        attr: function (name, value) {
+            return jQuery.access(this, jQuery.attr, name, value, arguments.length > 1);
+        },
+
+        removeAttr: function (name) {
+            return this.each(function () {
+                jQuery.removeAttr(this, name);
+            });
+        },
+
+        prop: function (name, value) {
+            return jQuery.access(this, jQuery.prop, name, value, arguments.length > 1);
+        },
+
+        removeProp: function (name) {
+            name = jQuery.propFix[name] || name;
+            return this.each(function () {
+                // try/catch handles cases where IE balks (such as removing a property on window)
+                try {
+                    this[name] = undefined;
+                    delete this[name];
+                } catch (e) {
+                }
+            });
+        },
+
+        addClass: function (value) {
+            var classNames, i, l, elem,
+                setClass, c, cl;
+
+            if (jQuery.isFunction(value)) {
+                return this.each(function (j) {
+                    jQuery(this).addClass(value.call(this, j, this.className));
+                });
+            }
+
+            if (value && typeof value === "string") {
+                classNames = value.split(core_rspace);
+
+                for (i = 0, l = this.length; i < l; i++) {
+                    elem = this[i];
+
+                    if (elem.nodeType === 1) {
+                        if (!elem.className && classNames.length === 1) {
+                            elem.className = value;
+
+                        } else {
+                            setClass = " " + elem.className + " ";
+
+                            for (c = 0, cl = classNames.length; c < cl; c++) {
+                                if (setClass.indexOf(" " + classNames[c] + " ") < 0) {
+                                    setClass += classNames[c] + " ";
+                                }
+                            }
+                            elem.className = jQuery.trim(setClass);
+                        }
+                    }
+                }
+            }
+
+            return this;
+        },
+
+        removeClass: function (value) {
+            var removes, className, elem, c, cl, i, l;
+
+            if (jQuery.isFunction(value)) {
+                return this.each(function (j) {
+                    jQuery(this).removeClass(value.call(this, j, this.className));
+                });
+            }
+            if ((value && typeof value === "string") || value === undefined) {
+                removes = ( value || "" ).split(core_rspace);
+
+                for (i = 0, l = this.length; i < l; i++) {
+                    elem = this[i];
+                    if (elem.nodeType === 1 && elem.className) {
+
+                        className = (" " + elem.className + " ").replace(rclass, " ");
+
+                        // loop over each item in the removal list
+                        for (c = 0, cl = removes.length; c < cl; c++) {
+                            // Remove until there is nothing to remove,
+                            while (className.indexOf(" " + removes[c] + " ") >= 0) {
+                                className = className.replace(" " + removes[c] + " ", " ");
+                            }
+                        }
+                        elem.className = value ? jQuery.trim(className) : "";
+                    }
+                }
+            }
+
+            return this;
+        },
+
+        toggleClass: function (value, stateVal) {
+            var type = typeof value,
+                isBool = typeof stateVal === "boolean";
+
+            if (jQuery.isFunction(value)) {
+                return this.each(function (i) {
+                    jQuery(this).toggleClass(value.call(this, i, this.className, stateVal), stateVal);
+                });
+            }
+
+            return this.each(function () {
+                if (type === "string") {
+                    // toggle individual class names
+                    var className,
+                        i = 0,
+                        self = jQuery(this),
+                        state = stateVal,
+                        classNames = value.split(core_rspace);
+
+                    while ((className = classNames[i++])) {
+                        // check each className given, space separated list
+                        state = isBool ? state : !self.hasClass(className);
+                        self[state ? "addClass" : "removeClass"](className);
+                    }
+
+                } else if (type === "undefined" || type === "boolean") {
+                    if (this.className) {
+                        // store className if set
+                        jQuery._data(this, "__className__", this.className);
+                    }
+
+                    // toggle whole className
+                    this.className = this.className || value === false ? "" : jQuery._data(this, "__className__") || "";
+                }
+            });
+        },
+
+        hasClass: function (selector) {
+            var className = " " + selector + " ",
+                i = 0,
+                l = this.length;
+            for (; i < l; i++) {
+                if (this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf(className) >= 0) {
+                    return true;
+                }
+            }
+
+            return false;
+        },
+
+        val: function (value) {
+            var hooks, ret, isFunction,
+                elem = this[0];
+
+            if (!arguments.length) {
+                if (elem) {
+                    hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()];
+
+                    if (hooks && "get" in hooks && (ret = hooks.get(elem, "value")) !== undefined) {
+                        return ret;
+                    }
+
+                    ret = elem.value;
+
+                    return typeof ret === "string" ?
+                        // handle most common string cases
+                        ret.replace(rreturn, "") :
+                        // handle cases where value is null/undef or number
+                        ret == null ? "" : ret;
+                }
+
+                return;
+            }
+
+            isFunction = jQuery.isFunction(value);
+
+            return this.each(function (i) {
+                var val,
+                    self = jQuery(this);
+
+                if (this.nodeType !== 1) {
+                    return;
+                }
+
+                if (isFunction) {
+                    val = value.call(this, i, self.val());
+                } else {
+                    val = value;
+                }
+
+                // Treat null/undefined as ""; convert numbers to string
+                if (val == null) {
+                    val = "";
+                } else if (typeof val === "number") {
+                    val += "";
+                } else if (jQuery.isArray(val)) {
+                    val = jQuery.map(val, function (value) {
+                        return value == null ? "" : value + "";
+                    });
+                }
+
+                hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()];
+
+                // If set returns undefined, fall back to normal setting
+                if (!hooks || !("set" in hooks) || hooks.set(this, val, "value") === undefined) {
+                    this.value = val;
+                }
+            });
+        }
+    });
+
+    jQuery.extend({
+        valHooks: {
+            option: {
+                get: function (elem) {
+                    // attributes.value is undefined in Blackberry 4.7 but
+                    // uses .value. See #6932
+                    var val = elem.attributes.value;
+                    return !val || val.specified ? elem.value : elem.text;
+                }
+            },
+            select: {
+                get: function (elem) {
+                    var value, 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
+                            ( jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null ) &&
+                            ( !option.parentNode.disabled || !jQuery.nodeName(option.parentNode, "optgroup") )) {
+
+                            // Get the specific value for the option
+                            value = jQuery(option).val();
+
+                            // We don't need an array for one selects
+                            if (one) {
+                                return value;
+                            }
+
+                            // Multi-Selects return an array
+                            values.push(value);
+                        }
+                    }
+
+                    return values;
+                },
+
+                set: function (elem, value) {
+                    var values = jQuery.makeArray(value);
+
+                    jQuery(elem).find("option").each(function () {
+                        this.selected = jQuery.inArray(jQuery(this).val(), values) >= 0;
+                    });
+
+                    if (!values.length) {
+                        elem.selectedIndex = -1;
+                    }
+                    return values;
+                }
+            }
+        },
+
+        // Unused in 1.8, left in so attrFn-stabbers won't die; remove in 1.9
+        attrFn: {},
+
+        attr: function (elem, name, value, pass) {
+            var ret, hooks, notxml,
+                nType = elem.nodeType;
+
+            // don't get/set attributes on text, comment and attribute nodes
+            if (!elem || nType === 3 || nType === 8 || nType === 2) {
+                return;
+            }
+
+            if (pass && jQuery.isFunction(jQuery.fn[name])) {
+                return jQuery(elem)[name](value);
+            }
+
+            // Fallback to prop when attributes are not supported
+            if (typeof elem.getAttribute === "undefined") {
+                return jQuery.prop(elem, name, value);
+            }
+
+            notxml = nType !== 1 || !jQuery.isXMLDoc(elem);
+
+            // All attributes are lowercase
+            // Grab necessary hook if one is defined
+            if (notxml) {
+                n

<TRUNCATED>

Mime
View raw message