/*! * jQuery Migrate - v3.3.2 - 2020-11-17T23:22Z * 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.2'; // 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' ); migrateWarnFunc( jQuery, 'isArray', Array.isArray, 'jQuery.isArray is deprecated; use Array.isArray' ); } 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' ); } // Support jQuery slim which excludes the ajax module if (jQuery.ajax) { var oldAjax = jQuery.ajax, rjsonp = /(=)\?(?=&|$)|\?\?/; 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; }; // Only trigger the logic in jQuery <4 as the JSON-to-JSONP auto-promotion // behavior is gone in jQuery 4.0 and as it has security implications, we don't // want to restore the legacy behavior. if (!jQueryVersionSince('4.0.0')) { // Register this prefilter before the jQuery one. Otherwise, a promoted // request is transformed into one with the script dataType and we can't // catch it anymore. jQuery.ajaxPrefilter('+json', function (s) { // Warn if JSON-to-JSONP auto-promotion happens. if ( s.jsonp !== false && (rjsonp.test(s.url) || (typeof s.data === 'string' && (s.contentType || '').indexOf( 'application/x-www-form-urlencoded' ) === 0 && rjsonp.test(s.data))) ) { migrateWarn('JSON-to-JSONP auto-promotion is deprecated'); } }); } } 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', 'reliableMarginLeft'], 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 camelName, origThis = this; if (name && typeof name === 'object' && !Array.isArray(name)) { jQuery.each(name, function (n, v) { jQuery.fn.css.call(origThis, n, v); }); return this; } if (typeof value === 'number') { camelName = camelCase(name); if (!isAutoPx(camelName) && !jQuery.cssNumber[camelName]) { migrateWarn( 'Number-typed values are deprecated for jQuery.fn.css( "' + name + '", value )' ); } } 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.off() 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.on( '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>'); 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>'); }; }; jQuery.htmlPrefilter = function (html) { warnIfChanged(html); return origHtmlPrefilter(html); }; var oldOffset = jQuery.fn.offset; jQuery.fn.offset = function () { var elem = this[0]; if (elem && (!elem.nodeType || !elem.getBoundingClientRect)) { migrateWarn('jQuery.fn.offset() requires a valid DOM element'); return arguments.length ? this : undefined; } 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; });