/*!
 * jQuery Migrate - v3.3.0 - 2020-05-05T01:57Z
 * Copyright OpenJS Foundation and other contributors
 */
(function (factory) {
    "use strict";

    if (typeof define === "function" && define.amd) {

        // AMD. Register as an anonymous module.
        define(["jquery"], function (jQuery) {
            return factory(jQuery, window);
        });
    } else if (typeof module === "object" && module.exports) {

        // Node/CommonJS
        // eslint-disable-next-line no-undef
        module.exports = factory(require("jquery"), window);
    } else {

        // Browser globals
        factory(jQuery, window);
    }
})(function (jQuery, window) {
    "use strict";

    jQuery.migrateVersion = "3.3.0";

// Returns 0 if v1 == v2, -1 if v1 < v2, 1 if v1 > v2
    function compareVersions(v1, v2) {
        var i,
            rVersionParts = /^(\d+)\.(\d+)\.(\d+)/,
            v1p = rVersionParts.exec(v1) || [],
            v2p = rVersionParts.exec(v2) || [];

        for (i = 1; i <= 3; i++) {
            if (+v1p[i] > +v2p[i]) {
                return 1;
            }
            if (+v1p[i] < +v2p[i]) {
                return -1;
            }
        }
        return 0;
    }

    function jQueryVersionSince(version) {
        return compareVersions(jQuery.fn.jquery, version) >= 0;
    }

    (function () {

        // Support: IE9 only
        // IE9 only creates console object when dev tools are first opened
        // IE9 console is a host object, callable but doesn't have .apply()
        if (!window.console || !window.console.log) {
            return;
        }

        // Need jQuery 3.0.0+ and no older Migrate loaded
        if (!jQuery || !jQueryVersionSince("3.0.0")) {
            window.console.log("JQMIGRATE: jQuery 3.0.0+ REQUIRED");
        }
        if (jQuery.migrateWarnings) {
            window.console.log("JQMIGRATE: Migrate plugin loaded multiple times");
        }

        // Show a message on the console so devs know we're active
        window.console.log("JQMIGRATE: Migrate is installed" +
            (jQuery.migrateMute ? "" : " with logging active") +
            ", version " + jQuery.migrateVersion);

    })();

    var warnedAbout = {};

// By default each warning is only reported once.
    jQuery.migrateDeduplicateWarnings = true;

// List of warnings already given; public read only
    jQuery.migrateWarnings = [];

// Set to false to disable traces that appear with warnings
    if (jQuery.migrateTrace === undefined) {
        jQuery.migrateTrace = true;
    }

// Forget any warnings we've already given; public
    jQuery.migrateReset = function () {
        warnedAbout = {};
        jQuery.migrateWarnings.length = 0;
    };

    function migrateWarn(msg) {
        var console = window.console;
        if (!jQuery.migrateDeduplicateWarnings || !warnedAbout[msg]) {
            warnedAbout[msg] = true;
            jQuery.migrateWarnings.push(msg);
            if (console && console.warn && !jQuery.migrateMute) {
                console.warn("JQMIGRATE: " + msg);
                if (jQuery.migrateTrace && console.trace) {
                    console.trace();
                }
            }
        }
    }

    function migrateWarnProp(obj, prop, value, msg) {
        Object.defineProperty(obj, prop, {
            configurable: true,
            enumerable: true,
            get: function () {
                migrateWarn(msg);
                return value;
            },
            set: function (newValue) {
                migrateWarn(msg);
                value = newValue;
            }
        });
    }

    function migrateWarnFunc(obj, prop, newFunc, msg) {
        obj[prop] = function () {
            migrateWarn(msg);
            return newFunc.apply(this, arguments);
        };
    }

    if (window.document.compatMode === "BackCompat") {

        // JQuery has never supported or tested Quirks Mode
        migrateWarn("jQuery is not compatible with Quirks Mode");
    }

    var findProp,
        class2type = {},
        oldInit = jQuery.fn.init,
        oldFind = jQuery.find,

        rattrHashTest = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/,
        rattrHashGlob = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/g,

        // Support: Android <=4.0 only
        // Make sure we trim BOM and NBSP
        rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;

    jQuery.fn.init = function (arg1) {
        var args = Array.prototype.slice.call(arguments);

        if (typeof arg1 === "string" && arg1 === "#") {

            // JQuery( "#" ) is a bogus ID selector, but it returned an empty set before jQuery 3.0
            migrateWarn("jQuery( '#' ) is not a valid selector");
            args[0] = [];
        }

        return oldInit.apply(this, args);
    };
    jQuery.fn.init.prototype = jQuery.fn;

    jQuery.find = function (selector) {
        var args = Array.prototype.slice.call(arguments);

        // Support: PhantomJS 1.x
        // String#match fails to match when used with a //g RegExp, only on some strings
        if (typeof selector === "string" && rattrHashTest.test(selector)) {

            // The nonstandard and undocumented unquoted-hash was removed in jQuery 1.12.0
            // First see if qS thinks it's a valid selector, if so avoid a false positive
            try {
                window.document.querySelector(selector);
            } catch (err1) {

                // Didn't *look* valid to qSA, warn and try quoting what we think is the value
                selector = selector.replace(rattrHashGlob, function (_, attr, op, value) {
                    return "[" + attr + op + "\"" + value + "\"]";
                });

                // If the regexp *may* have created an invalid selector, don't update it
                // Note that there may be false alarms if selector uses jQuery extensions
                try {
                    window.document.querySelector(selector);
                    migrateWarn("Attribute selector with '#' must be quoted: " + args[0]);
                    args[0] = selector;
                } catch (err2) {
                    migrateWarn("Attribute selector with '#' was not fixed: " + args[0]);
                }
            }
        }

        return oldFind.apply(this, args);
    };

// Copy properties attached to original jQuery.find method (e.g. .attr, .isXML)
    for (findProp in oldFind) {
        if (Object.prototype.hasOwnProperty.call(oldFind, findProp)) {
            jQuery.find[findProp] = oldFind[findProp];
        }
    }

// The number of elements contained in the matched element set
    migrateWarnFunc(jQuery.fn, "size", function () {
            return this.length;
        },
        "jQuery.fn.size() is deprecated and removed; use the .length property");

    migrateWarnFunc(jQuery, "parseJSON", function () {
            return JSON.parse.apply(null, arguments);
        },
        "jQuery.parseJSON is deprecated; use JSON.parse");

    migrateWarnFunc(jQuery, "holdReady", jQuery.holdReady,
        "jQuery.holdReady is deprecated");

    migrateWarnFunc(jQuery, "unique", jQuery.uniqueSort,
        "jQuery.unique is deprecated; use jQuery.uniqueSort");

// Now jQuery.expr.pseudos is the standard incantation
    migrateWarnProp(jQuery.expr, "filters", jQuery.expr.pseudos,
        "jQuery.expr.filters is deprecated; use jQuery.expr.pseudos");
    migrateWarnProp(jQuery.expr, ":", jQuery.expr.pseudos,
        "jQuery.expr[':'] is deprecated; use jQuery.expr.pseudos");

// Prior to jQuery 3.1.1 there were internal refs so we don't warn there
    if (jQueryVersionSince("3.1.1")) {
        migrateWarnFunc(jQuery, "trim", function (text) {
                return text == null ?
                    "" :
                    (text + "").replace(rtrim, "");
            },
            "jQuery.trim is deprecated; use String.prototype.trim");
    }

// Prior to jQuery 3.2 there were internal refs so we don't warn there
    if (jQueryVersionSince("3.2.0")) {
        migrateWarnFunc(jQuery, "nodeName", function (elem, name) {
                return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
            },
            "jQuery.nodeName is deprecated");
    }

    if (jQueryVersionSince("3.3.0")) {

        migrateWarnFunc(jQuery, "isNumeric", function (obj) {

                // As of jQuery 3.0, isNumeric is limited to
                // strings and numbers (primitives or objects)
                // that can be coerced to finite numbers (gh-2662)
                var type = typeof obj;
                return (type === "number" || type === "string") &&

                    // parseFloat NaNs numeric-cast false positives ("")
                    // ...but misinterprets leading-number strings, e.g. hex literals ("0x...")
                    // subtraction forces infinities to NaN
                    !isNaN(obj - parseFloat(obj));
            },
            "jQuery.isNumeric() is deprecated"
        );

        // Populate the class2type map
        jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),
            function (_, name) {
                class2type["[object " + name + "]"] = name.toLowerCase();
            });

        migrateWarnFunc(jQuery, "type", function (obj) {
                if (obj == null) {
                    return obj + "";
                }

                // Support: Android <=2.3 only (functionish RegExp)
                return typeof obj === "object" || typeof obj === "function" ?
                    class2type[Object.prototype.toString.call(obj)] || "object" :
                    typeof obj;
            },
            "jQuery.type is deprecated");

        migrateWarnFunc(jQuery, "isFunction",
            function (obj) {
                return typeof obj === "function";
            },
            "jQuery.isFunction() is deprecated");

        migrateWarnFunc(jQuery, "isWindow",
            function (obj) {
                return obj != null && obj === obj.window;
            },
            "jQuery.isWindow() is deprecated"
        );

        migrateWarnFunc(jQuery, "isArray", Array.isArray,
            "jQuery.isArray is deprecated; use Array.isArray"
        );
    }

// Support jQuery slim which excludes the ajax module
    if (jQuery.ajax) {

        var oldAjax = jQuery.ajax;

        jQuery.ajax = function () {
            var jQXHR = oldAjax.apply(this, arguments);

            // Be sure we got a jQXHR (e.g., not sync)
            if (jQXHR.promise) {
                migrateWarnFunc(jQXHR, "success", jQXHR.done,
                    "jQXHR.success is deprecated and removed");
                migrateWarnFunc(jQXHR, "error", jQXHR.fail,
                    "jQXHR.error is deprecated and removed");
                migrateWarnFunc(jQXHR, "complete", jQXHR.always,
                    "jQXHR.complete is deprecated and removed");
            }

            return jQXHR;
        };

    }

    var oldRemoveAttr = jQuery.fn.removeAttr,
        oldToggleClass = jQuery.fn.toggleClass,
        rmatchNonSpace = /\S+/g;

    jQuery.fn.removeAttr = function (name) {
        var self = this;

        jQuery.each(name.match(rmatchNonSpace), function (_i, attr) {
            if (jQuery.expr.match.bool.test(attr)) {
                migrateWarn("jQuery.fn.removeAttr no longer sets boolean properties: " + attr);
                self.prop(attr, false);
            }
        });

        return oldRemoveAttr.apply(this, arguments);
    };

    jQuery.fn.toggleClass = function (state) {

        // Only deprecating no-args or single boolean arg
        if (state !== undefined && typeof state !== "boolean") {
            return oldToggleClass.apply(this, arguments);
        }

        migrateWarn("jQuery.fn.toggleClass( boolean ) is deprecated");

        // Toggle entire class name of each element
        return this.each(function () {
            var className = this.getAttribute && this.getAttribute("class") || "";

            if (className) {
                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.
            if (this.setAttribute) {
                this.setAttribute("class",
                    className || state === false ?
                        "" :
                        jQuery.data(this, "__className__") || ""
                );
            }
        });
    };

    function camelCase(string) {
        return string.replace(/-([a-z])/g, function (_, letter) {
            return letter.toUpperCase();
        });
    }

    var oldFnCss,
        internalSwapCall = false,
        ralphaStart = /^[a-z]/,

        // The regex visualized:
        //
        //                         /----------\
        //                        |            |    /-------\
        //                        |  / Top  \  |   |         |
        //         /--- Border ---+-| Right  |-+---+- Width -+---\
        //        |                 | Bottom |                    |
        //        |                  \ Left /                     |
        //        |                                               |
        //        |                              /----------\     |
        //        |          /-------------\    |            |    |- END
        //        |         |               |   |  / Top  \  |    |
        //        |         |  / Margin  \  |   | | Right  | |    |
        //        |---------+-|           |-+---+-| Bottom |-+----|
        //        |            \ Padding /         \ Left /       |
        // BEGIN -|                                               |
        //        |                /---------\                    |
        //        |               |           |                   |
        //        |               |  / Min \  |    / Width  \     |
        //         \--------------+-|       |-+---|          |---/
        //                           \ Max /       \ Height /
        rautoPx = /^(?:Border(?:Top|Right|Bottom|Left)?(?:Width|)|(?:Margin|Padding)?(?:Top|Right|Bottom|Left)?|(?:Min|Max)?(?:Width|Height))$/;

// If this version of jQuery has .swap(), don't false-alarm on internal uses
    if (jQuery.swap) {
        jQuery.each(["height", "width", "reliableMarginRight"], function (_, name) {
            var oldHook = jQuery.cssHooks[name] && jQuery.cssHooks[name].get;

            if (oldHook) {
                jQuery.cssHooks[name].get = function () {
                    var ret;

                    internalSwapCall = true;
                    ret = oldHook.apply(this, arguments);
                    internalSwapCall = false;
                    return ret;
                };
            }
        });
    }

    jQuery.swap = function (elem, options, callback, args) {
        var ret, name,
            old = {};

        if (!internalSwapCall) {
            migrateWarn("jQuery.swap() is undocumented and deprecated");
        }

        // 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;
    };

    if (jQueryVersionSince("3.4.0") && typeof Proxy !== "undefined") {

        jQuery.cssProps = new Proxy(jQuery.cssProps || {}, {
            set: function () {
                migrateWarn("JQMIGRATE: jQuery.cssProps is deprecated");
                return Reflect.set.apply(this, arguments);
            }
        });
    }

// Create a dummy jQuery.cssNumber if missing. It won't be used by jQuery but
// it will prevent code adding new keys to it unconditionally from crashing.
    if (!jQuery.cssNumber) {
        jQuery.cssNumber = {};
    }

    function isAutoPx(prop) {

        // The first test is used to ensure that:
        // 1. The prop starts with a lowercase letter (as we uppercase it for the second regex).
        // 2. The prop is not empty.
        return ralphaStart.test(prop) &&
            rautoPx.test(prop[0].toUpperCase() + prop.slice(1));
    }

    oldFnCss = jQuery.fn.css;

    jQuery.fn.css = function (name, value) {
        var origThis = this;
        if (typeof name !== "string") {
            jQuery.each(name, function (n, v) {
                jQuery.fn.css.call(origThis, n, v);
            });
        }
        if (typeof value === "number" && !isAutoPx(camelCase(name))) {
            migrateWarn("Use of number-typed values is deprecated in jQuery.fn.css");
        }

        return oldFnCss.apply(this, arguments);
    };

    var oldData = jQuery.data;

    jQuery.data = function (elem, name, value) {
        var curData, sameKeys, key;

        // Name can be an object, and each entry in the object is meant to be set as data
        if (name && typeof name === "object" && arguments.length === 2) {
            curData = jQuery.hasData(elem) && oldData.call(this, elem);
            sameKeys = {};
            for (key in name) {
                if (key !== camelCase(key)) {
                    migrateWarn("jQuery.data() always sets/gets camelCased names: " + key);
                    curData[key] = name[key];
                } else {
                    sameKeys[key] = name[key];
                }
            }

            oldData.call(this, elem, sameKeys);

            return name;
        }

        // If the name is transformed, look for the un-transformed name in the data object
        if (name && typeof name === "string" && name !== camelCase(name)) {
            curData = jQuery.hasData(elem) && oldData.call(this, elem);
            if (curData && name in curData) {
                migrateWarn("jQuery.data() always sets/gets camelCased names: " + name);
                if (arguments.length > 2) {
                    curData[name] = value;
                }
                return curData[name];
            }
        }

        return oldData.apply(this, arguments);
    };

// Support jQuery slim which excludes the effects module
    if (jQuery.fx) {

        var intervalValue, intervalMsg,
            oldTweenRun = jQuery.Tween.prototype.run,
            linearEasing = function (pct) {
                return pct;
            };

        jQuery.Tween.prototype.run = function () {
            if (jQuery.easing[this.easing].length > 1) {
                migrateWarn(
                    "'jQuery.easing." + this.easing.toString() + "' should use only one argument"
                );

                jQuery.easing[this.easing] = linearEasing;
            }

            oldTweenRun.apply(this, arguments);
        };

        intervalValue = jQuery.fx.interval || 13;
        intervalMsg = "jQuery.fx.interval is deprecated";

// Support: IE9, Android <=4.4
// Avoid false positives on browsers that lack rAF
// Don't warn if document is hidden, jQuery uses setTimeout (#292)
        if (window.requestAnimationFrame) {
            Object.defineProperty(jQuery.fx, "interval", {
                configurable: true,
                enumerable: true,
                get: function () {
                    if (!window.document.hidden) {
                        migrateWarn(intervalMsg);
                    }
                    return intervalValue;
                },
                set: function (newValue) {
                    migrateWarn(intervalMsg);
                    intervalValue = newValue;
                }
            });
        }

    }

    var oldLoad = jQuery.fn.load,
        oldEventAdd = jQuery.event.add,
        originalFix = jQuery.event.fix;

    jQuery.event.props = [];
    jQuery.event.fixHooks = {};

    migrateWarnProp(jQuery.event.props, "concat", jQuery.event.props.concat,
        "jQuery.event.props.concat() is deprecated and removed");

    jQuery.event.fix = function (originalEvent) {
        var event,
            type = originalEvent.type,
            fixHook = this.fixHooks[type],
            props = jQuery.event.props;

        if (props.length) {
            migrateWarn("jQuery.event.props are deprecated and removed: " + props.join());
            while (props.length) {
                jQuery.event.addProp(props.pop());
            }
        }

        if (fixHook && !fixHook._migrated_) {
            fixHook._migrated_ = true;
            migrateWarn("jQuery.event.fixHooks are deprecated and removed: " + type);
            if ((props = fixHook.props) && props.length) {
                while (props.length) {
                    jQuery.event.addProp(props.pop());
                }
            }
        }

        event = originalFix.call(this, originalEvent);

        return fixHook && fixHook.filter ? fixHook.filter(event, originalEvent) : event;
    };

    jQuery.event.add = function (elem, types) {

        // This misses the multiple-types case but that seems awfully rare
        if (elem === window && types === "load" && window.document.readyState === "complete") {
            migrateWarn("jQuery(window).on('load'...) called after load event occurred");
        }
        return oldEventAdd.apply(this, arguments);
    };

    jQuery.each(["load", "unload", "error"], function (_, name) {

        jQuery.fn[name] = function () {
            var args = Array.prototype.slice.call(arguments, 0);

            // If this is an ajax load() the first arg should be the string URL;
            // technically this could also be the "Anything" arg of the event .load()
            // which just goes to show why this dumb signature has been deprecated!
            // jQuery custom builds that exclude the Ajax module justifiably die here.
            if (name === "load" && typeof args[0] === "string") {
                return oldLoad.apply(this, args);
            }

            migrateWarn("jQuery.fn." + name + "() is deprecated");

            args.splice(0, 0, name);
            if (arguments.length) {
                return this.on.apply(this, args);
            }

            // Use .triggerHandler here because:
            // - load and unload events don't need to bubble, only applied to window or image
            // - error event should not bubble to window, although it does pre-1.7
            // See http://bugs.jquery.com/ticket/11820
            this.triggerHandler.apply(this, args);
            return this;
        };

    });

    jQuery.each(("blur focus focusin focusout resize scroll click dblclick " +
        "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
        "change select submit keydown keypress keyup contextmenu").split(" "),
        function (_i, name) {

            // Handle event binding
            jQuery.fn[name] = function (data, fn) {
                migrateWarn("jQuery.fn." + name + "() event shorthand is deprecated");
                return arguments.length > 0 ?
                    this.on(name, null, data, fn) :
                    this.trigger(name);
            };
        });

// Trigger "ready" event only once, on document ready
    jQuery(function () {
        jQuery(window.document).triggerHandler("ready");
    });

    jQuery.event.special.ready = {
        setup: function () {
            if (this === window.document) {
                migrateWarn("'ready' event is deprecated");
            }
        }
    };

    jQuery.fn.extend({

        bind: function (types, data, fn) {
            migrateWarn("jQuery.fn.bind() is deprecated");
            return this.on(types, null, data, fn);
        },
        unbind: function (types, fn) {
            migrateWarn("jQuery.fn.unbind() is deprecated");
            return this.off(types, null, fn);
        },
        delegate: function (selector, types, data, fn) {
            migrateWarn("jQuery.fn.delegate() is deprecated");
            return this.on(types, selector, data, fn);
        },
        undelegate: function (selector, types, fn) {
            migrateWarn("jQuery.fn.undelegate() is deprecated");
            return arguments.length === 1 ?
                this.off(selector, "**") :
                this.off(types, selector || "**", fn);
        },
        hover: function (fnOver, fnOut) {
            migrateWarn("jQuery.fn.hover() is deprecated");
            return this.on("mouseenter", fnOver).on("mouseleave", fnOut || fnOver);
        }
    });

    var rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,
        origHtmlPrefilter = jQuery.htmlPrefilter,
        makeMarkup = function (html) {
            var doc = window.document.implementation.createHTMLDocument("");
            doc.body.innerHTML = html;
            return doc.body && doc.body.innerHTML;
        },
        warnIfChanged = function (html) {
            var changed = html.replace(rxhtmlTag, "<$1></$2>");
            if (changed !== html && makeMarkup(html) !== makeMarkup(changed)) {
                migrateWarn("HTML tags must be properly nested and closed: " + html);
            }
        };

    jQuery.UNSAFE_restoreLegacyHtmlPrefilter = function () {
        jQuery.htmlPrefilter = function (html) {
            warnIfChanged(html);
            return html.replace(rxhtmlTag, "<$1></$2>");
        };
    };

    jQuery.htmlPrefilter = function (html) {
        warnIfChanged(html);
        return origHtmlPrefilter(html);
    };

    var oldOffset = jQuery.fn.offset;

    jQuery.fn.offset = function () {
        var docElem,
            elem = this[0],
            bogus = {top: 0, left: 0};

        if (!elem || !elem.nodeType) {
            migrateWarn("jQuery.fn.offset() requires a valid DOM element");
            return undefined;
        }

        docElem = (elem.ownerDocument || window.document).documentElement;
        if (!jQuery.contains(docElem, elem)) {
            migrateWarn("jQuery.fn.offset() requires an element connected to a document");
            return bogus;
        }

        return oldOffset.apply(this, arguments);
    };

// Support jQuery slim which excludes the ajax module
// The jQuery.param patch is about respecting `jQuery.ajaxSettings.traditional`
// so it doesn't make sense for the slim build.
    if (jQuery.ajax) {

        var oldParam = jQuery.param;

        jQuery.param = function (data, traditional) {
            var ajaxTraditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;

            if (traditional === undefined && ajaxTraditional) {

                migrateWarn("jQuery.param() no longer uses jQuery.ajaxSettings.traditional");
                traditional = ajaxTraditional;
            }

            return oldParam.call(this, data, traditional);
        };

    }

    var oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack;

    jQuery.fn.andSelf = function () {
        migrateWarn("jQuery.fn.andSelf() is deprecated and removed, use jQuery.fn.addBack()");
        return oldSelf.apply(this, arguments);
    };

// Support jQuery slim which excludes the deferred module in jQuery 4.0+
    if (jQuery.Deferred) {

        var oldDeferred = jQuery.Deferred,
            tuples = [

                // Action, add listener, callbacks, .then handlers, final state
                ["resolve", "done", jQuery.Callbacks("once memory"),
                    jQuery.Callbacks("once memory"), "resolved"],
                ["reject", "fail", jQuery.Callbacks("once memory"),
                    jQuery.Callbacks("once memory"), "rejected"],
                ["notify", "progress", jQuery.Callbacks("memory"),
                    jQuery.Callbacks("memory")]
            ];

        jQuery.Deferred = function (func) {
            var deferred = oldDeferred(),
                promise = deferred.promise();

            deferred.pipe = promise.pipe = function ( /* fnDone, fnFail, fnProgress */) {
                var fns = arguments;

                migrateWarn("deferred.pipe() is deprecated");

                return jQuery.Deferred(function (newDefer) {
                    jQuery.each(tuples, function (i, tuple) {
                        var fn = typeof fns[i] === "function" && fns[i];

                        // Deferred.done(function() { bind to newDefer or newDefer.resolve })
                        // deferred.fail(function() { bind to newDefer or newDefer.reject })
                        // deferred.progress(function() { bind to newDefer or newDefer.notify })
                        deferred[tuple[1]](function () {
                            var returned = fn && fn.apply(this, arguments);
                            if (returned && typeof returned.promise === "function") {
                                returned.promise()
                                    .done(newDefer.resolve)
                                    .fail(newDefer.reject)
                                    .progress(newDefer.notify);
                            } else {
                                newDefer[tuple[0] + "With"](
                                    this === promise ? newDefer.promise() : this,
                                    fn ? [returned] : arguments
                                );
                            }
                        });
                    });
                    fns = null;
                }).promise();

            };

            if (func) {
                func.call(deferred, deferred);
            }

            return deferred;
        };

// Preserve handler of uncaught exceptions in promise chains
        jQuery.Deferred.exceptionHook = oldDeferred.exceptionHook;

    }

    return jQuery;
});