jekyll-theme-anatole 0.1.2

data/assets/js/jquery-migrate.js

@@ -0,0 +1,882 @@
+/*!
+ * 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;
+});